pp2p-core 0.1.0__tar.gz

pp2p_core-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: pp2p_core
+Version: 0.1.0
+Summary: Python ctypes SDK for the PP2P Rust core
+Author: PP2P
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Python SDK
+
+This package is a ctypes bridge over the PP2P Rust C ABI.
+
+## Install
+
+```bash
+pip install pp2p_core
+```
+
+## Runtime requirements
+
+- Python 3.9+
+- Native PP2P core library (`pp2p_core.dll` / `libpp2p_core.so` / `libpp2p_core.dylib`)
+
+Build native library first:
+
+Windows:
+```powershell
+.\scripts\build_pp2p_core.ps1
+```
+
+Linux/macOS:
+```bash
+./scripts/build_pp2p_core_unix.sh
+```
+
+If the library is not in `dist/pp2p_core/...`, set `PP2P_CORE_LIB` to its absolute path.
+
+## Local dev install
+
+```bash
+pip install -e ./bindings/python
+```
+
+## Example
+
+```python
+from pp2p_core import Pp2pCore
+
+core = Pp2pCore()
+alice = core.generate_identity()
+bob = core.generate_identity()
+
+env = core.sign_envelope(
+    private_key_b64=alice["private_key_b64"],
+    sender_peer_id=alice["peer_id"],
+    recipient_peer_id=bob["peer_id"],
+    payload={"type": "hello", "text": "hi"},
+    nonce="n1",
+)
+core.verify_envelope(env, signer_public_key_b64=alice["public_key_b64"])
+print("ok")
+```

pp2p_core-0.1.0/README.md

@@ -0,0 +1,54 @@
+# Python SDK
+
+This package is a ctypes bridge over the PP2P Rust C ABI.
+
+## Install
+
+```bash
+pip install pp2p_core
+```
+
+## Runtime requirements
+
+- Python 3.9+
+- Native PP2P core library (`pp2p_core.dll` / `libpp2p_core.so` / `libpp2p_core.dylib`)
+
+Build native library first:
+
+Windows:
+```powershell
+.\scripts\build_pp2p_core.ps1
+```
+
+Linux/macOS:
+```bash
+./scripts/build_pp2p_core_unix.sh
+```
+
+If the library is not in `dist/pp2p_core/...`, set `PP2P_CORE_LIB` to its absolute path.
+
+## Local dev install
+
+```bash
+pip install -e ./bindings/python
+```
+
+## Example
+
+```python
+from pp2p_core import Pp2pCore
+
+core = Pp2pCore()
+alice = core.generate_identity()
+bob = core.generate_identity()
+
+env = core.sign_envelope(
+    private_key_b64=alice["private_key_b64"],
+    sender_peer_id=alice["peer_id"],
+    recipient_peer_id=bob["peer_id"],
+    payload={"type": "hello", "text": "hi"},
+    nonce="n1",
+)
+core.verify_envelope(env, signer_public_key_b64=alice["public_key_b64"])
+print("ok")
+```

pp2p_core-0.1.0/pp2p_core.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: pp2p_core
+Version: 0.1.0
+Summary: Python ctypes SDK for the PP2P Rust core
+Author: PP2P
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Python SDK
+
+This package is a ctypes bridge over the PP2P Rust C ABI.
+
+## Install
+
+```bash
+pip install pp2p_core
+```
+
+## Runtime requirements
+
+- Python 3.9+
+- Native PP2P core library (`pp2p_core.dll` / `libpp2p_core.so` / `libpp2p_core.dylib`)
+
+Build native library first:
+
+Windows:
+```powershell
+.\scripts\build_pp2p_core.ps1
+```
+
+Linux/macOS:
+```bash
+./scripts/build_pp2p_core_unix.sh
+```
+
+If the library is not in `dist/pp2p_core/...`, set `PP2P_CORE_LIB` to its absolute path.
+
+## Local dev install
+
+```bash
+pip install -e ./bindings/python
+```
+
+## Example
+
+```python
+from pp2p_core import Pp2pCore
+
+core = Pp2pCore()
+alice = core.generate_identity()
+bob = core.generate_identity()
+
+env = core.sign_envelope(
+    private_key_b64=alice["private_key_b64"],
+    sender_peer_id=alice["peer_id"],
+    recipient_peer_id=bob["peer_id"],
+    payload={"type": "hello", "text": "hi"},
+    nonce="n1",
+)
+core.verify_envelope(env, signer_public_key_b64=alice["public_key_b64"])
+print("ok")
+```

pp2p_core-0.1.0/pp2p_core.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+README.md
+pp2p_core.py
+pyproject.toml
+pp2p_core.egg-info/PKG-INFO
+pp2p_core.egg-info/SOURCES.txt
+pp2p_core.egg-info/dependency_links.txt
+pp2p_core.egg-info/top_level.txt

pp2p_core-0.1.0/pp2p_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pp2p_core-0.1.0/pp2p_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+pp2p_core

pp2p_core-0.1.0/pp2p_core.py

@@ -0,0 +1,131 @@
+"""
+Python ctypes bridge for the Rust PP2P core C ABI.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import json
+import os
+import pathlib
+import time
+from typing import Any
+
+
+def _default_library_path() -> str:
+    env = os.environ.get("PP2P_CORE_LIB")
+    if env:
+        return env
+
+    if os.name == "nt":
+        rel = pathlib.Path("dist") / "pp2p_core" / "windows-x64" / "pp2p_core.dll"
+    elif os.uname().sysname == "Darwin":
+        rel = pathlib.Path("dist") / "pp2p_core" / "macos" / "libpp2p_core.dylib"
+    else:
+        rel = pathlib.Path("dist") / "pp2p_core" / "linux-x64" / "libpp2p_core.so"
+
+    candidates = [
+        pathlib.Path(__file__).resolve().parents[2] / rel,
+        pathlib.Path.cwd() / rel,
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return str(candidate)
+
+    # Return best-guess path so ctypes error mentions a useful location.
+    return str(candidates[0])
+
+
+class Pp2pCoreError(RuntimeError):
+    pass
+
+
+class Pp2pCore:
+    def __init__(self, lib_path: str | None = None) -> None:
+        path = lib_path or _default_library_path()
+        self._lib = ctypes.CDLL(path)
+
+        self._lib.pp2p_generate_identity_json.restype = ctypes.c_void_p
+        self._lib.pp2p_peer_id_from_public_key_b64.argtypes = [ctypes.c_char_p]
+        self._lib.pp2p_peer_id_from_public_key_b64.restype = ctypes.c_void_p
+        self._lib.pp2p_sign_envelope_json.argtypes = [
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_uint64,
+            ctypes.c_char_p,
+        ]
+        self._lib.pp2p_sign_envelope_json.restype = ctypes.c_void_p
+        self._lib.pp2p_verify_envelope_json.argtypes = [
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_uint64,
+            ctypes.c_uint64,
+        ]
+        self._lib.pp2p_verify_envelope_json.restype = ctypes.c_ubyte
+        self._lib.pp2p_last_error_message.restype = ctypes.c_void_p
+        self._lib.pp2p_free_string.argtypes = [ctypes.c_void_p]
+
+    def _take_string(self, ptr: int | None) -> str:
+        if not ptr:
+            raise Pp2pCoreError(self.last_error())
+        try:
+            raw = ctypes.cast(ptr, ctypes.c_char_p).value or b""
+            return raw.decode("utf-8")
+        finally:
+            self._lib.pp2p_free_string(ptr)
+
+    def last_error(self) -> str:
+        ptr = self._lib.pp2p_last_error_message()
+        if not ptr:
+            return "unknown error"
+        return self._take_string(ptr)
+
+    def generate_identity(self) -> dict[str, Any]:
+        ptr = self._lib.pp2p_generate_identity_json()
+        return json.loads(self._take_string(ptr))
+
+    def peer_id_from_public_key_b64(self, public_key_b64: str) -> str:
+        ptr = self._lib.pp2p_peer_id_from_public_key_b64(public_key_b64.encode("utf-8"))
+        return self._take_string(ptr)
+
+    def sign_envelope(
+        self,
+        private_key_b64: str,
+        sender_peer_id: str,
+        recipient_peer_id: str,
+        payload: dict[str, Any],
+        nonce: str,
+        timestamp_ms: int | None = None,
+    ) -> dict[str, Any]:
+        if timestamp_ms is None:
+            timestamp_ms = int(time.time() * 1000)
+        ptr = self._lib.pp2p_sign_envelope_json(
+            private_key_b64.encode("utf-8"),
+            sender_peer_id.encode("utf-8"),
+            recipient_peer_id.encode("utf-8"),
+            json.dumps(payload, separators=(",", ":")).encode("utf-8"),
+            ctypes.c_uint64(timestamp_ms),
+            nonce.encode("utf-8"),
+        )
+        return json.loads(self._take_string(ptr))
+
+    def verify_envelope(
+        self,
+        envelope: dict[str, Any],
+        signer_public_key_b64: str,
+        max_skew_ms: int = 60_000,
+        now_ms: int | None = None,
+    ) -> bool:
+        if now_ms is None:
+            now_ms = int(time.time() * 1000)
+        ok = self._lib.pp2p_verify_envelope_json(
+            json.dumps(envelope, separators=(",", ":")).encode("utf-8"),
+            signer_public_key_b64.encode("utf-8"),
+            ctypes.c_uint64(now_ms),
+            ctypes.c_uint64(max_skew_ms),
+        )
+        if ok == 1:
+            return True
+        raise Pp2pCoreError(self.last_error())

pp2p_core-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pp2p_core"
+version = "0.1.0"
+description = "Python ctypes SDK for the PP2P Rust core"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{ name = "PP2P" }]
+license = "MIT"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+]
+
+[tool.setuptools]
+py-modules = ["pp2p_core"]

pp2p_core-0.1.0/setup.cfg

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