kctsb 8.6.9__tar.gz

kctsb-8.6.9/MANIFEST.in

@@ -0,0 +1,12 @@
+include README.md
+include LICENSE
+
+recursive-include kctsb *.py *.pyd *.so *.dylib *.pyi
+recursive-include kctsb/_libs *.dll *.so *.dylib
+recursive-include kctsb/_kctsb_core *.pyi
+include kctsb/py.typed
+
+prune bindings
+prune tests
+prune __pycache__
+global-exclude *.pyc

kctsb-8.6.9/PKG-INFO

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: kctsb
+Version: 8.6.9
+Summary: High-performance cryptographic library — HE (CKKS/BFV/BGV), DP, PSI/PIR, VOPRF, SSS, MPC, PQ encoding, and encrypted ML inference. C++ core with Python bindings.
+Author-email: knightc <kcshareg@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/kn1ghtc/kctsb
+Project-URL: Documentation, https://github.com/kn1ghtc/kctsb#readme
+Project-URL: Repository, https://github.com/kn1ghtc/kctsb
+Project-URL: Issues, https://github.com/kn1ghtc/kctsb/issues
+Keywords: cryptography,homomorphic-encryption,ckks,bfv,bgv,differential-privacy,psi,pir,voprf,secret-sharing,mpc,garbled-circuit,rep3,secure-multiparty-computation,product-quantization,private-vector-search,encrypted-ml,privacy-preserving,pybind11
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+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 :: C++
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Provides-Extra: ml
+Requires-Dist: torch>=2.0; extra == "ml"
+Requires-Dist: transformers>=4.30; extra == "ml"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Provides-Extra: all
+Requires-Dist: kctsb[dev,ml]; extra == "all"
+
+# kctsb — Knight's Cryptographic Trusted Security Base
+
+High-performance cryptographic library with Python bindings for homomorphic encryption, differential privacy, private set intersection, PIR, MPC, Product Quantization (PQ) encoding, and encrypted ML inference.
+
+
+**C++ core + pybind11 bindings → native Python speed**
+
+## Features
+
+| Module | Description |
+|--------|-------------|
+| `kctsb.crypto` | **v8.6.9** — atomic primitives: AES-GCM (AES-NI), ChaCha20-Poly1305, SHA-256/512/3 (SHA-NI), HMAC, HKDF, constant-time CSPRNG, `secure_compare`, `token_bytes`, `token_hex`; hand-written PEP 561 type stubs for all public symbols |
+| `kctsb.ckks` | CKKS approximate homomorphic encryption (encode, encrypt, add, multiply, rotate) |
+| `kctsb.bfv` | BFV scale-invariant FHE for integer arithmetic |
+| `kctsb.bgv` | BGV leveled homomorphic encryption with Galois rotations |
+| `kctsb.dp` | Differential privacy (Laplace, Gaussian mechanisms, budget tracking) |
+| `kctsb.psi` | Private Set Intersection (Piano-PSI, OT-PSI with IKNP/KKRT) |
+| `kctsb.pir` | Private Information Retrieval (FHE-based, BGV/BFV/CKKS) |
+| `kctsb.ecc_blind_sign` | Clause Blind Schnorr signatures (FPS20) — ROS-resistant unlinkable tokens, public verifiable, AGM+ROM secure |  
+| `kctsb.voprf` | RFC 9497 VOPRF (P256-SHA256, OPRF/VOPRF/POPRF modes) — deterministic blinded PRF |
+| `kctsb.sss` | Shamir's Secret Sharing (GF(2^8), information-theoretic security) |
+| `kctsb.mpc` | Secure MPC primitives and benchmarks (Rep3 batch secret sharing, Half-Gates GC) |
+| `kctsb.encode` | **v8.6.9** — Product Quantization training, encoding, decoding, ADC lookup, and ADC top-k for private vector query search (PVQS) |
+| `kctsb.hcc` | Homomorphic Confidential Computing (6 privacy scenarios) |
+| `kctsb.upsi` | Unbalanced PSI + Symmetric Searchable Encryption |
+| `kctsb.core` | Hardware acceleration detection (AVX2/AVX512/AES-NI/CUDA) |
+| `kctsb.ml` | Encrypted ML inference (EncryptedTensor, neural network layers, pipeline) |
+
+## Quick Start
+
+```bash
+pip install kctsb
+```
+
+### Atomic Crypto Primitives (v8.6.9)
+
+Hardware-accelerated primitives (AES-NI / SHA-NI). Requires Python 3.10+.
+
+```python
+from kctsb.crypto import (
+    AESGCM, ChaCha20Poly1305,
+    sha256, sha512, sha3_256,
+    hmac_sha256, hmac_sha512, hkdf_sha256,
+    random_bytes, random_uint32, random_uint64, random_range,
+    secure_compare, token_bytes, token_hex,
+)
+
+# AES-256-GCM (AES-NI accelerated)
+key = AESGCM.generate_key(256)     # bit length
+nonce = random_bytes(12)
+aead = AESGCM(key)
+ct = aead.encrypt(nonce, b"hello", b"aad")
+pt = aead.decrypt(nonce, ct, b"aad")
+
+# SHA-NI accelerated hashing
+digest = sha256(b"payload")         # 32-byte bytes
+tag    = hmac_sha256(key, b"msg")   # 32-byte bytes
+
+# Constant-time CSPRNG (platform RtlGenRandom / getrandom)
+secret = token_bytes(32)
+hexstr = token_hex(16)
+
+# HKDF-SHA256
+okm = hkdf_sha256(ikm=secret, salt=b"salt", info=b"context", length=64)
+```
+
+### Product Quantization Encoding (v8.6.9)
+
+Compress high-dimensional feature vectors into compact PQ codes and run ADC top-k search. This module is designed for PVQS-style private vector retrieval pipelines where the online private query only carries compact candidate/key handles.
+
+```python
+import numpy as np
+from kctsb import encode
+
+vectors = np.random.default_rng(20260508).normal(size=(4096, 512)).astype(np.float32)
+query = vectors[0]
+
+codebooks = encode.train_pq(vectors, subquantizers=32, centroids=64, max_iterations=8)
+codes = encode.encode_pq(vectors, codebooks)
+lookup = encode.adc_lookup(query, codebooks)
+indices, distances = encode.adc_topk(codes, lookup, top_k=10)
+```
+
+### CKKS Homomorphic Encryption
+
+```python
+from kctsb import CKKSContext
+
+ctx = CKKSContext(poly_modulus_degree=8192, coeff_modulus_levels=5, scale_bits=40)
+sk = ctx.keygen()
+pk = ctx.public_key(sk)
+
+pt = ctx.encode([1.0, 2.0, 3.0])
+ct = ctx.encrypt(pk, pt)
+ct_sum = ctx.add(ct, ct)
+result = ctx.decrypt_decode(sk, ct_sum)
+print(result[:3])  # [2.0, 4.0, 6.0]
+```
+
+### Differential Privacy
+
+```python
+from kctsb.dp import DPMechanism, DPBudget
+
+noise = DPMechanism.laplace(sensitivity=1.0, epsilon=0.1)
+noisy_data = DPMechanism.add_noise([1.0, 2.0, 3.0], sensitivity=1.0, epsilon=0.1)
+
+budget = DPBudget(total_epsilon=1.0)
+budget.consume(0.1)
+print(f"Remaining ε: {budget.remaining_epsilon}")
+```
+
+### Private Set Intersection
+
+```python
+from kctsb._kctsb_core import psi
+
+client_set = list(range(1, 101))
+server_set = list(range(50, 151))
+piano = psi.PianoPSI()
+result = piano.compute(client_set, server_set)
+print(f"Intersection size: {len(result.intersection)}")
+```
+
+### Multi-Party Computation (MPC)
+
+The Python package now exposes `kctsb.mpc` for secure MPC primitives and performance benchmarking. Use this module to access Rep3 batch secret sharing APIs and Half-Gates garbled-circuit benchmarks directly from Python.
+
+### Shamir's Secret Sharing
+
+```python
+from kctsb._kctsb_core import sss
+
+secret = b"my_secret_key_32bytes_long!!!!!"
+shares = sss.ShamirSSS.split(secret, threshold=3, num_shares=5)
+recovered = sss.ShamirSSS.reconstruct(shares[:3], len(secret))
+assert recovered == secret
+```
+
+### Hardware Detection
+
+```python
+from kctsb._kctsb_core import core
+
+hw = core.detect_hardware()
+print(f"AVX2: {hw['avx2']}, AES-NI: {hw['aes_ni']}, CUDA: {hw['cuda']}")
+core.print_status()
+```
+
+## Building from Source
+
+Developers with the full kctsb source tree can build locally:
+
+```powershell
+# Windows (PowerShell)
+cd kctsb
+.\scripts\build_python.ps1
+
+# Or manually:
+$env:PATH = "C:\msys64\mingw64\bin;$env:PATH"
+cmake -B build_release -G Ninja -DCMAKE_BUILD_TYPE=Release -DKCTSB_BUILD_PYTHON=ON
+cmake --build build_release --parallel 16
+pip install ./python
+```
+
+## Requirements
+
+- Python 3.10+
+- NumPy >= 1.24
+- Windows x64 (pre-built), Linux/macOS (build from source)
+
+## Optional Dependencies
+
+```bash
+pip install kctsb[ml]   # + torch, transformers for encrypted ML
+pip install kctsb[dev]  # + pytest, build, twine for development
+pip install kctsb[all]  # Everything
+```
+
+## Changelog
+
+### v8.6.9 (2026-05)
+- Added `kctsb.encode` Product Quantization primitives for PVQS: PQ training, batch encode/decode, ADC lookup, and ADC top-k.
+- Added PEP 561 type hints for `kctsb.encode` and refreshed blind-signature stubs to match the P-256 pybind11 API.
+- Added PVQS notebook and protocol design documentation for low-communication private theme/resource retrieval.
+
+### v8.6.6 (2026-04)
+- **Breaking**: removed `_hashlib` / `_hmac` compat shim objects from `kctsb.crypto`.
+    Use `sha256`, `hmac_sha256`, `token_bytes` etc. directly.
+- Added hand-written PEP 561 type stubs (`*.pyi`) for all public symbols in
+    `kctsb.crypto`, `kctsb.ckks`, `kctsb.dp`, `kctsb.sss` and all `_kctsb_core` sub-modules.
+- Secure RAG demo: Phase 0 bootstrap and corpus loader extracted to standalone helper modules.
+
+## License
+Apache-2.0 — Copyright (c) 2019-2026 knightc

kctsb-8.6.9/README.md

@@ -0,0 +1,195 @@
+# kctsb — Knight's Cryptographic Trusted Security Base
+
+High-performance cryptographic library with Python bindings for homomorphic encryption, differential privacy, private set intersection, PIR, MPC, Product Quantization (PQ) encoding, and encrypted ML inference.
+
+
+**C++ core + pybind11 bindings → native Python speed**
+
+## Features
+
+| Module | Description |
+|--------|-------------|
+| `kctsb.crypto` | **v8.6.9** — atomic primitives: AES-GCM (AES-NI), ChaCha20-Poly1305, SHA-256/512/3 (SHA-NI), HMAC, HKDF, constant-time CSPRNG, `secure_compare`, `token_bytes`, `token_hex`; hand-written PEP 561 type stubs for all public symbols |
+| `kctsb.ckks` | CKKS approximate homomorphic encryption (encode, encrypt, add, multiply, rotate) |
+| `kctsb.bfv` | BFV scale-invariant FHE for integer arithmetic |
+| `kctsb.bgv` | BGV leveled homomorphic encryption with Galois rotations |
+| `kctsb.dp` | Differential privacy (Laplace, Gaussian mechanisms, budget tracking) |
+| `kctsb.psi` | Private Set Intersection (Piano-PSI, OT-PSI with IKNP/KKRT) |
+| `kctsb.pir` | Private Information Retrieval (FHE-based, BGV/BFV/CKKS) |
+| `kctsb.ecc_blind_sign` | Clause Blind Schnorr signatures (FPS20) — ROS-resistant unlinkable tokens, public verifiable, AGM+ROM secure |  
+| `kctsb.voprf` | RFC 9497 VOPRF (P256-SHA256, OPRF/VOPRF/POPRF modes) — deterministic blinded PRF |
+| `kctsb.sss` | Shamir's Secret Sharing (GF(2^8), information-theoretic security) |
+| `kctsb.mpc` | Secure MPC primitives and benchmarks (Rep3 batch secret sharing, Half-Gates GC) |
+| `kctsb.encode` | **v8.6.9** — Product Quantization training, encoding, decoding, ADC lookup, and ADC top-k for private vector query search (PVQS) |
+| `kctsb.hcc` | Homomorphic Confidential Computing (6 privacy scenarios) |
+| `kctsb.upsi` | Unbalanced PSI + Symmetric Searchable Encryption |
+| `kctsb.core` | Hardware acceleration detection (AVX2/AVX512/AES-NI/CUDA) |
+| `kctsb.ml` | Encrypted ML inference (EncryptedTensor, neural network layers, pipeline) |
+
+## Quick Start
+
+```bash
+pip install kctsb
+```
+
+### Atomic Crypto Primitives (v8.6.9)
+
+Hardware-accelerated primitives (AES-NI / SHA-NI). Requires Python 3.10+.
+
+```python
+from kctsb.crypto import (
+    AESGCM, ChaCha20Poly1305,
+    sha256, sha512, sha3_256,
+    hmac_sha256, hmac_sha512, hkdf_sha256,
+    random_bytes, random_uint32, random_uint64, random_range,
+    secure_compare, token_bytes, token_hex,
+)
+
+# AES-256-GCM (AES-NI accelerated)
+key = AESGCM.generate_key(256)     # bit length
+nonce = random_bytes(12)
+aead = AESGCM(key)
+ct = aead.encrypt(nonce, b"hello", b"aad")
+pt = aead.decrypt(nonce, ct, b"aad")
+
+# SHA-NI accelerated hashing
+digest = sha256(b"payload")         # 32-byte bytes
+tag    = hmac_sha256(key, b"msg")   # 32-byte bytes
+
+# Constant-time CSPRNG (platform RtlGenRandom / getrandom)
+secret = token_bytes(32)
+hexstr = token_hex(16)
+
+# HKDF-SHA256
+okm = hkdf_sha256(ikm=secret, salt=b"salt", info=b"context", length=64)
+```
+
+### Product Quantization Encoding (v8.6.9)
+
+Compress high-dimensional feature vectors into compact PQ codes and run ADC top-k search. This module is designed for PVQS-style private vector retrieval pipelines where the online private query only carries compact candidate/key handles.
+
+```python
+import numpy as np
+from kctsb import encode
+
+vectors = np.random.default_rng(20260508).normal(size=(4096, 512)).astype(np.float32)
+query = vectors[0]
+
+codebooks = encode.train_pq(vectors, subquantizers=32, centroids=64, max_iterations=8)
+codes = encode.encode_pq(vectors, codebooks)
+lookup = encode.adc_lookup(query, codebooks)
+indices, distances = encode.adc_topk(codes, lookup, top_k=10)
+```
+
+### CKKS Homomorphic Encryption
+
+```python
+from kctsb import CKKSContext
+
+ctx = CKKSContext(poly_modulus_degree=8192, coeff_modulus_levels=5, scale_bits=40)
+sk = ctx.keygen()
+pk = ctx.public_key(sk)
+
+pt = ctx.encode([1.0, 2.0, 3.0])
+ct = ctx.encrypt(pk, pt)
+ct_sum = ctx.add(ct, ct)
+result = ctx.decrypt_decode(sk, ct_sum)
+print(result[:3])  # [2.0, 4.0, 6.0]
+```
+
+### Differential Privacy
+
+```python
+from kctsb.dp import DPMechanism, DPBudget
+
+noise = DPMechanism.laplace(sensitivity=1.0, epsilon=0.1)
+noisy_data = DPMechanism.add_noise([1.0, 2.0, 3.0], sensitivity=1.0, epsilon=0.1)
+
+budget = DPBudget(total_epsilon=1.0)
+budget.consume(0.1)
+print(f"Remaining ε: {budget.remaining_epsilon}")
+```
+
+### Private Set Intersection
+
+```python
+from kctsb._kctsb_core import psi
+
+client_set = list(range(1, 101))
+server_set = list(range(50, 151))
+piano = psi.PianoPSI()
+result = piano.compute(client_set, server_set)
+print(f"Intersection size: {len(result.intersection)}")
+```
+
+### Multi-Party Computation (MPC)
+
+The Python package now exposes `kctsb.mpc` for secure MPC primitives and performance benchmarking. Use this module to access Rep3 batch secret sharing APIs and Half-Gates garbled-circuit benchmarks directly from Python.
+
+### Shamir's Secret Sharing
+
+```python
+from kctsb._kctsb_core import sss
+
+secret = b"my_secret_key_32bytes_long!!!!!"
+shares = sss.ShamirSSS.split(secret, threshold=3, num_shares=5)
+recovered = sss.ShamirSSS.reconstruct(shares[:3], len(secret))
+assert recovered == secret
+```
+
+### Hardware Detection
+
+```python
+from kctsb._kctsb_core import core
+
+hw = core.detect_hardware()
+print(f"AVX2: {hw['avx2']}, AES-NI: {hw['aes_ni']}, CUDA: {hw['cuda']}")
+core.print_status()
+```
+
+## Building from Source
+
+Developers with the full kctsb source tree can build locally:
+
+```powershell
+# Windows (PowerShell)
+cd kctsb
+.\scripts\build_python.ps1
+
+# Or manually:
+$env:PATH = "C:\msys64\mingw64\bin;$env:PATH"
+cmake -B build_release -G Ninja -DCMAKE_BUILD_TYPE=Release -DKCTSB_BUILD_PYTHON=ON
+cmake --build build_release --parallel 16
+pip install ./python
+```
+
+## Requirements
+
+- Python 3.10+
+- NumPy >= 1.24
+- Windows x64 (pre-built), Linux/macOS (build from source)
+
+## Optional Dependencies
+
+```bash
+pip install kctsb[ml]   # + torch, transformers for encrypted ML
+pip install kctsb[dev]  # + pytest, build, twine for development
+pip install kctsb[all]  # Everything
+```
+
+## Changelog
+
+### v8.6.9 (2026-05)
+- Added `kctsb.encode` Product Quantization primitives for PVQS: PQ training, batch encode/decode, ADC lookup, and ADC top-k.
+- Added PEP 561 type hints for `kctsb.encode` and refreshed blind-signature stubs to match the P-256 pybind11 API.
+- Added PVQS notebook and protocol design documentation for low-communication private theme/resource retrieval.
+
+### v8.6.6 (2026-04)
+- **Breaking**: removed `_hashlib` / `_hmac` compat shim objects from `kctsb.crypto`.
+    Use `sha256`, `hmac_sha256`, `token_bytes` etc. directly.
+- Added hand-written PEP 561 type stubs (`*.pyi`) for all public symbols in
+    `kctsb.crypto`, `kctsb.ckks`, `kctsb.dp`, `kctsb.sss` and all `_kctsb_core` sub-modules.
+- Secure RAG demo: Phase 0 bootstrap and corpus loader extracted to standalone helper modules.
+
+## License
+Apache-2.0 — Copyright (c) 2019-2026 knightc

kctsb-8.6.9/kctsb/__init__.py

@@ -0,0 +1,98 @@
+"""
+kctsb - Knight's Cryptographic Trusted Security Base (Python Interface)
+
+High-performance homomorphic encryption, differential privacy, and encrypted
+ML inference library. Python bindings for the kctsb C++ cryptographic core.
+
+Architecture:
+    Python API (kctsb.ckks, kctsb.dp, kctsb.ml)
+        ↓
+    pybind11 bindings (_kctsb_core)
+        ↓
+    C++ core (libkctsb_static)
+
+Usage:
+    >>> import kctsb
+    >>> ctx = kctsb.CKKSContext(poly_modulus_degree=8192,
+    ...                         coeff_modulus_levels=5,
+    ...                         scale_bits=40)
+    >>> sk = ctx.keygen()
+    >>> pk = ctx.public_key(sk)
+    >>> pt = ctx.encode([1.0, 2.0, 3.0])
+    >>> ct = ctx.encrypt(pk, pt)
+    >>> result = ctx.decrypt(sk, ct)
+    >>> values = ctx.decode(result)
+
+Author: knightc
+Copyright: (c) 2019-2026 knightc. All rights reserved.
+License: Apache-2.0
+"""
+
+import os
+import sys
+import logging
+
+__version__ = "8.6.9"
+__author__ = "knightc"
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# DLL loader: add bundled runtime libraries to DLL search path (Windows)
+# ---------------------------------------------------------------------------
+_libs_dir = os.path.join(os.path.dirname(__file__), "_libs")
+_dll_handle = None
+if sys.platform == "win32" and os.path.isdir(_libs_dir):
+    try:
+        _dll_handle = os.add_dll_directory(_libs_dir)
+        logger.debug("Added DLL directory: %s", _libs_dir)
+    except OSError:
+        logger.warning("Failed to add DLL directory: %s", _libs_dir)
+
+# Try to import the compiled C++ core module
+try:
+    from ._kctsb_core import ckks as _ckks_core
+    from ._kctsb_core import dp as _dp_core
+    from ._kctsb_core import __version__ as _core_version
+    _HAS_CORE = True
+except ImportError as exc:
+    _HAS_CORE = False
+    _core_version = "N/A (core not compiled)"
+    logger.warning("kctsb C++ core not available: %s", exc)
+
+# Re-export C++ submodules without Python wrapper conflicts
+# Usage: from kctsb import bfv, psi, pir, crypto, ...
+if _HAS_CORE:
+    from ._kctsb_core import bfv, bgv, psi, pir, hcc, upsi, voprf, sss, core, mpc
+    from ._kctsb_core import ecc_blind_sign
+    from ._kctsb_core import encode
+
+# High-level Python facades (keep these AFTER the core re-exports so they win on name conflicts)
+from . import crypto
+from .ckks import CKKSContext
+from .dp import DPMechanism, DPBudget
+from . import dp
+
+__all__ = [
+    # High-level Python wrappers
+    "CKKSContext",
+    "DPMechanism",
+    "DPBudget",
+    # Python facade modules
+    "crypto",
+    "dp",
+    # C++ submodules (direct re-exports)
+    "bfv",
+    "bgv",
+    "psi",
+    "pir",
+    "hcc",
+    "upsi",
+    "voprf",
+    "ecc_blind_sign",
+    "sss",
+    "core",
+    "mpc",
+    "encode",
+    "__version__",
+]

kctsb-8.6.9/kctsb/__init__.pyi

@@ -0,0 +1,30 @@
+"""Type stubs for the top-level ``kctsb`` package.
+
+Re-exports the high-level Python facades (:class:`CKKSContext`,
+:class:`DPMechanism`, :class:`DPBudget`) and the C++ submodules
+(``crypto``, ``dp``, ``ckks``, ``bfv``, ``bgv``, ``psi``, ``pir``,
+``hcc``, ``upsi``, ``voprf``, ``sss``, ``core``, ``mpc``).
+"""
+from __future__ import annotations
+
+from . import bfv as bfv
+from . import bgv as bgv
+from . import ckks as ckks
+from . import core as core
+from . import crypto as crypto
+from . import dp as dp
+from . import ecc_blind_sign as ecc_blind_sign
+from . import hcc as hcc
+from . import mpc as mpc
+from . import pir as pir
+from . import psi as psi
+from . import sss as sss
+from . import upsi as upsi
+from . import voprf as voprf
+from .ckks import CKKSContext as CKKSContext
+from .dp import DPBudget as DPBudget, DPMechanism as DPMechanism
+
+__version__: str
+__author__: str
+
+__all__: list[str]