idb-engine 0.1.0__py3-none-win_amd64.whl

idb/__init__.py

@@ -0,0 +1,322 @@
+"""idb — Python bindings for the idb embedded database (ctypes → idb_engine)."""
+
+from __future__ import annotations
+
+import ctypes
+import json
+import os
+import platform
+from ctypes import c_char_p, c_uint32, c_void_p
+from typing import Any, Optional
+
+EXPECTED_API_VERSION = 2
+
+
+class IdbError(RuntimeError):
+    """Raised when an IQL/FFI call returns ``{"error": ...}`` and check=True."""
+
+
+def _default_library_name() -> str:
+    system = platform.system().lower()
+    if "windows" in system:
+        return "idb_engine.dll"
+    if "darwin" in system:
+        return "libidb_engine.dylib"
+    return "libidb_engine.so"
+
+
+def _plat_dir() -> str:
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    if "windows" in system:
+        return "win_amd64" if machine in ("amd64", "x86_64") else f"win_{machine}"
+    if "darwin" in system:
+        return "macosx_arm64" if machine in ("arm64", "aarch64") else "macosx_x86_64"
+    return "manylinux_x86_64" if machine in ("x86_64", "amd64") else f"manylinux_{machine}"
+
+
+def _candidate_library_paths(explicit: str | None) -> list[str]:
+    name = _default_library_name()
+    here = os.path.dirname(os.path.abspath(__file__))
+    pkg_root = here
+    repo_root = os.path.dirname(here)
+    if os.path.basename(here) == "idb" and os.path.basename(repo_root) == "python":
+        repo_root = os.path.dirname(repo_root)
+        pkg_root = here
+    out: list[str] = []
+    if explicit:
+        out.append(explicit)
+    env = os.environ.get("IDB_LIBRARY_PATH")
+    if env:
+        out.append(env)
+    out.append(os.path.join(pkg_root, "_bin", _plat_dir(), name))
+    out.append(os.path.join(repo_root, "idb", "_bin", _plat_dir(), name))
+    out.append(os.path.join(repo_root, "target", "release", name))
+    out.append(os.path.join(here, "..", "target", "release", name))
+    out.append(os.path.join(repo_root, "target", "debug", name))
+    out.append(os.path.join(here, "..", "target", "debug", name))
+    seen: set[str] = set()
+    uniq: list[str] = []
+    for p in out:
+        ap = os.path.normpath(os.path.abspath(p))
+        if ap not in seen:
+            seen.add(ap)
+            uniq.append(ap)
+    return uniq
+
+
+def _bind(lib: ctypes.CDLL) -> None:
+    lib.idb_open.restype = c_void_p
+    lib.idb_open.argtypes = [c_char_p]
+    if hasattr(lib, "idb_open_with_key"):
+        lib.idb_open_with_key.restype = c_void_p
+        lib.idb_open_with_key.argtypes = [c_char_p, c_char_p]
+    lib.idb_connect.restype = c_void_p
+    lib.idb_connect.argtypes = [c_void_p]
+    lib.idb_disconnect.argtypes = [c_void_p]
+    # IMPORTANT: string results must be c_void_p so we can idb_free_str the real pointer.
+    # c_char_p would auto-convert and make free_str corrupt the heap.
+    for name in (
+        "idb_run",
+        "idb_conn_run",
+        "idb_run_with_params",
+        "idb_begin",
+        "idb_commit",
+        "idb_abort",
+        "idb_conn_begin",
+        "idb_conn_commit",
+        "idb_conn_abort",
+        "idb_checkpoint",
+        "idb_gc",
+        "idb_vacuum",
+        "idb_schema_info",
+    ):
+        if hasattr(lib, name):
+            getattr(lib, name).restype = c_void_p
+    lib.idb_run.argtypes = [c_void_p, c_char_p]
+    lib.idb_conn_run.argtypes = [c_void_p, c_char_p]
+    lib.idb_run_with_params.argtypes = [c_void_p, c_char_p, c_char_p]
+    if hasattr(lib, "idb_conn_run_with_params"):
+        lib.idb_conn_run_with_params.restype = c_void_p
+        lib.idb_conn_run_with_params.argtypes = [c_void_p, c_char_p, c_char_p]
+    for name in (
+        "idb_begin",
+        "idb_commit",
+        "idb_abort",
+        "idb_conn_begin",
+        "idb_conn_commit",
+        "idb_conn_abort",
+        "idb_checkpoint",
+        "idb_gc",
+        "idb_vacuum",
+        "idb_schema_info",
+    ):
+        getattr(lib, name).argtypes = [c_void_p]
+    if hasattr(lib, "idb_vacuum_full"):
+        lib.idb_vacuum_full.restype = c_void_p
+        lib.idb_vacuum_full.argtypes = [c_void_p]
+    if hasattr(lib, "idb_backup"):
+        lib.idb_backup.restype = c_void_p
+        lib.idb_backup.argtypes = [c_void_p, c_char_p]
+    lib.idb_close.argtypes = [c_void_p]
+    lib.idb_free_str.argtypes = [c_void_p]
+    if hasattr(lib, "idb_api_version"):
+        lib.idb_api_version.restype = c_uint32
+        lib.idb_api_version.argtypes = []
+    if hasattr(lib, "idb_format_version"):
+        lib.idb_format_version.restype = c_uint32
+        lib.idb_format_version.argtypes = []
+
+
+def _load_lib(library_path: str | None = None) -> ctypes.CDLL:
+    last_err: OSError | None = None
+    lib: ctypes.CDLL | None = None
+    for path in _candidate_library_paths(library_path):
+        if not os.path.isfile(path):
+            continue
+        try:
+            lib = ctypes.CDLL(path)
+            break
+        except OSError as e:
+            last_err = e
+            continue
+    if lib is None:
+        tried = "\n  ".join(_candidate_library_paths(library_path))
+        raise RuntimeError(
+            "failed to load idb_engine shared library.\n"
+            "Install a platform wheel (pip install idb-engine) or build natives:\n"
+            "  powershell -File scripts/build-release.ps1\n"
+            "  # or: scripts/build-release.sh\n"
+            f"Tried:\n  {tried}"
+        ) from last_err
+    _bind(lib)
+    if hasattr(lib, "idb_api_version"):
+        ver = int(lib.idb_api_version())
+        if ver < EXPECTED_API_VERSION:
+            raise RuntimeError(
+                f"idb_engine API {ver} < required {EXPECTED_API_VERSION}; rebuild the shared library"
+            )
+    return lib
+
+
+def _raise_if_error(results: list[Any], check: bool) -> list[Any]:
+    if not check:
+        return results
+    for item in results:
+        if isinstance(item, dict) and "error" in item:
+            raise IdbError(str(item["error"]))
+    return results
+
+
+class IdbConnection:
+    """Отдельная session (явные begin/commit не пересекаются с другими)."""
+
+    def __init__(self, lib: ctypes.CDLL, handle: int, check: bool = True):
+        self._lib = lib
+        self._conn = handle
+        self.check = check
+
+    def run(self, script: str) -> list[Any]:
+        raw = self._lib.idb_conn_run(self._conn, script.encode("utf-8"))
+        return _raise_if_error(self._decode(raw), self.check)
+
+    def run_with_params(self, script: str, params: dict) -> list[Any]:
+        if not hasattr(self._lib, "idb_conn_run_with_params"):
+            raise RuntimeError("idb_conn_run_with_params unavailable")
+        raw = self._lib.idb_conn_run_with_params(
+            self._conn,
+            script.encode("utf-8"),
+            json.dumps(params).encode("utf-8"),
+        )
+        return _raise_if_error(self._decode(raw), self.check)
+
+    def begin(self) -> list[Any]:
+        return _raise_if_error(self._decode(self._lib.idb_conn_begin(self._conn)), self.check)
+
+    def commit(self) -> list[Any]:
+        return _raise_if_error(self._decode(self._lib.idb_conn_commit(self._conn)), self.check)
+
+    def abort(self) -> list[Any]:
+        return _raise_if_error(self._decode(self._lib.idb_conn_abort(self._conn)), self.check)
+
+    def _decode(self, raw) -> list[Any]:
+        if not raw:
+            return []
+        try:
+            text = ctypes.string_at(raw).decode("utf-8")
+            return json.loads(text)
+        finally:
+            self._lib.idb_free_str(raw)
+
+    def close(self) -> None:
+        if self._conn:
+            self._lib.idb_disconnect(self._conn)
+            self._conn = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+class Idb:
+    def __init__(
+        self,
+        db_path: str,
+        library_path: str | None = None,
+        key: str | None = None,
+        check: bool = True,
+    ):
+        self._lib = _load_lib(library_path)
+        self.check = check
+        key = key or os.environ.get("IDB_KEY")
+        if key:
+            if not hasattr(self._lib, "idb_open_with_key"):
+                raise RuntimeError("idb_open_with_key unavailable")
+            self._db = self._lib.idb_open_with_key(
+                db_path.encode("utf-8"), key.encode("utf-8")
+            )
+        else:
+            self._db = self._lib.idb_open(db_path.encode("utf-8"))
+        if not self._db:
+            raise RuntimeError(f"failed to open database: {db_path}")
+
+    def connect(self) -> IdbConnection:
+        handle = self._lib.idb_connect(self._db)
+        if not handle:
+            raise RuntimeError("idb_connect failed")
+        return IdbConnection(self._lib, handle, check=self.check)
+
+    def run(self, script: str) -> list[Any]:
+        raw = self._lib.idb_run(self._db, script.encode("utf-8"))
+        return _raise_if_error(self._decode_json(raw), self.check)
+
+    def run_with_params(self, script: str, params: dict) -> list[Any]:
+        raw = self._lib.idb_run_with_params(
+            self._db,
+            script.encode("utf-8"),
+            json.dumps(params).encode("utf-8"),
+        )
+        return _raise_if_error(self._decode_json(raw), self.check)
+
+    def begin(self) -> list[Any]:
+        return _raise_if_error(self._decode_json(self._lib.idb_begin(self._db)), self.check)
+
+    def commit(self) -> list[Any]:
+        return _raise_if_error(self._decode_json(self._lib.idb_commit(self._db)), self.check)
+
+    def abort(self) -> list[Any]:
+        return _raise_if_error(self._decode_json(self._lib.idb_abort(self._db)), self.check)
+
+    def checkpoint(self) -> list[Any]:
+        return _raise_if_error(self._decode_json(self._lib.idb_checkpoint(self._db)), self.check)
+
+    def gc(self) -> list[Any]:
+        return _raise_if_error(self._decode_json(self._lib.idb_gc(self._db)), self.check)
+
+    def vacuum(self) -> list[Any]:
+        return _raise_if_error(self._decode_json(self._lib.idb_vacuum(self._db)), self.check)
+
+    def vacuum_full(self) -> list[Any]:
+        if not hasattr(self._lib, "idb_vacuum_full"):
+            raise RuntimeError("idb_vacuum_full unavailable")
+        return _raise_if_error(
+            self._decode_json(self._lib.idb_vacuum_full(self._db)), self.check
+        )
+
+    def backup(self, dest: str) -> list[Any]:
+        if not hasattr(self._lib, "idb_backup"):
+            raise RuntimeError("idb_backup unavailable")
+        return _raise_if_error(
+            self._decode_json(self._lib.idb_backup(self._db, dest.encode("utf-8"))),
+            self.check,
+        )
+
+    def schema_info(self) -> list[Any]:
+        return _raise_if_error(
+            self._decode_json(self._lib.idb_schema_info(self._db)), self.check
+        )
+
+    def _decode_json(self, raw) -> list[Any]:
+        if not raw:
+            return []
+        try:
+            text = ctypes.string_at(raw).decode("utf-8")
+            return json.loads(text)
+        finally:
+            self._lib.idb_free_str(raw)
+
+    def close(self) -> None:
+        if self._db:
+            self._lib.idb_close(self._db)
+            self._db = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.close()
+
+
+__all__ = ["Idb", "IdbConnection", "IdbError", "EXPECTED_API_VERSION"]

idb_engine-0.1.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: idb-engine
+Version: 0.1.0
+Summary: Embedded multi-model database (binary package; source is proprietary)
+Author: IDB
+Project-URL: Homepage, https://github.com/tretakovpavel681-design/IDB-realese
+Project-URL: Releases, https://github.com/tretakovpavel681-design/IDB-realese/releases
+Keywords: database,embedded,iql,ffi
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# IDB
+
+Встраиваемая multi-model база данных. **Бесплатна для использования.**  
+Распространяется как готовые программы и пакеты (**без исходного кода**).
+
+## Скачать
+
+| Что | Откуда |
+|-----|--------|
+| CLI (`idb.exe` / `idb`) | [GitHub Releases](https://github.com/tretakovpavel681-design/IDB/releases) |
+| Python | `pip install idb-engine` (когда пакет опубликован) или `.whl` из Releases |
+| Node.js | `npm install idb-engine` (когда пакет опубликован) или `.tgz` из Releases |
+
+Сборка из исходников **не предлагается** — исходный код закрыт.
+
+## Быстрый старт (CLI)
+
+1. Скачайте `idb` / `idb.exe` для вашей ОС из Releases.
+2. Запустите:
+
+```text
+idb demo.idb
+```
+
+Если файла нет — создаётся новый `demo.idb` (как у SQLite: один файл БД рядом с программой).
+
+```text
+idb --json demo.idb script.iql
+idb --key <64-hex-символа> secure.idb
+```
+
+Команды shell: `.exit` `.help` `.schemas` `.vacuum` `.checkpoint` `.backup` `.gc`
+
+## Python
+
+```bash
+pip install idb-engine
+```
+
+```python
+from idb import Idb
+
+with Idb("demo.idb") as db:
+    db.run("create schema Item index by id")
+    db.run("insert Item =\n    id = 1\n    name = Ada")
+    print(db.run("select Item =\n    name"))
+```
+
+Шифрование страниц: `Idb("sec.idb", key="…64 hex…")` или переменная `IDB_KEY`.
+
+## Node.js
+
+```bash
+npm install idb-engine koffi
+```
+
+```js
+const { Idb } = require("idb-engine");
+const db = new Idb("demo.idb");
+db.run("create schema Item index by id");
+console.log(db.run("select Item =\n    id"));
+db.close();
+```
+
+## Возможности
+
+- файл `.idb` + WAL / MVCC / vacuum / backup  
+- язык запросов IQL (CRUD, фильтры, joins, EXISTS, FTS, EXPLAIN)  
+- индексы B+Tree, covering, HashJoin  
+- опциональное шифрование страниц  
+- FFI для встраивания (C / Python / JS) — см. бинарный SDK в Releases  
+
+## Лицензия
+
+Бесплатное использование бинарников. Исходный код **не** открыт.  
+См. файл [LICENSE](LICENSE).
+
+## Поддержка
+
+Issues / обсуждения — в репозитории Releases или указанном канале поддержки правообладателя.

idb_engine-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+idb/__init__.py,sha256=GqJE2hCggulVzggn8G1zomMxjBND6tBWK4Ulv0Se1WQ,11440
+idb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idb/_bin/win_amd64/idb.exe,sha256=_-aJEzeF-cIkXrvsLSgk-7Y_3mdN0VIWPampWaN9b-U,1679872
+idb/_bin/win_amd64/idb_engine.dll,sha256=n-_My7INa3a6DBQCKrSJHtClX29b52Tm5FtLozHmVjA,1678848
+idb_engine-0.1.0.dist-info/licenses/LICENSE,sha256=-cwne5e-ovijZLbKmWwMZPJsU1u0yXBiUe2yR7VJD6A,2411
+idb_engine-0.1.0.dist-info/METADATA,sha256=2Y2uMoX9OWGYQNGpnENcb0-S0SPTiC1-BP-AYsCJoWQ,3321
+idb_engine-0.1.0.dist-info/WHEEL,sha256=3I5VVWZdsFlU417aCS2bMRuerS8wsfvBq99MyatBV3A,97
+idb_engine-0.1.0.dist-info/top_level.txt,sha256=w7UowfB_EDA-_Ui_mVJPjF7QrDIig_z0vmq5ZAGw3oY,4
+idb_engine-0.1.0.dist-info/RECORD,,

idb_engine-0.1.0.dist-info/WHEEL

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

idb_engine-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,55 @@
+IDB Freeware License (Binary Distribution)
+Version 1.0
+
+Copyright (c) 2026 IDB authors. All rights reserved.
+
+SUMMARY
+  IDB is provided free of charge as compiled binaries and language
+  packages (CLI, shared libraries, pip/npm wheels). Source code is
+  proprietary and is not licensed for public use or redistribution.
+
+1. GRANT OF LICENSE
+  Subject to this License, you may install and use the IDB software
+  (the "Software"), free of charge, for any purpose, including
+  personal and commercial use, on any number of machines.
+
+2. WHAT YOU MAY DO
+  - Use the Software as an embedded or standalone database.
+  - Redistribute unmodified official binary packages (CLI installers,
+    platform wheels, npm tarballs) obtained from the copyright holder
+    or authorized release channels, provided this License accompanies
+    them and you do not charge a separate fee solely for the Software
+    itself (hosting/bandwidth costs are fine).
+
+3. WHAT YOU MAY NOT DO
+  - Copy, publish, share, or redistribute the Software source code.
+  - Create derivative works from the source code.
+  - Reverse engineer, decompile, or disassemble the Software except
+    to the limited extent that applicable law expressly prohibits
+    such restriction.
+  - Remove or alter copyright, attribution, or license notices.
+  - Use the name "IDB" or related marks to imply endorsement of
+    your product without prior written permission.
+
+4. NO SOURCE CODE LICENSE
+  This License does not grant any rights to the Software source code,
+  build scripts beyond what is needed to consume official packages,
+  tests, or internal documentation. Access to source (if any) is
+  under a separate written agreement only.
+
+5. UPDATES
+  Updates may be provided at the copyright holder's discretion and
+  are governed by this License unless accompanied by different terms.
+
+6. NO WARRANTY
+  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 ARISING FROM
+  USE OF THE SOFTWARE.
+
+7. TERMINATION
+  This License terminates automatically if you breach it. Upon
+  termination you must stop using and destroy copies of the Software
+  obtained under this License, except as required by law.

idb_engine-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+idb