iibin 2.0.0a1__tar.gz

iibin-2.0.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jochen Schultz <js@intelligent-intern.com>
+
+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.

iibin-2.0.0a1/MANIFEST.in

@@ -0,0 +1,2 @@
+include native/python.c native/core/wire.c native/core/wire.h
+include RELEASING.md

iibin-2.0.0a1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: iibin
+Version: 2.0.0a1
+Summary: Schema-defined IIBIN binary messages with a native C codec
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Intelligent-Intern/iibin-py
+Project-URL: Issues, https://github.com/Intelligent-Intern/iibin-py/issues
+Keywords: iibin,serialization,binary,protobuf,codec
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: C
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# IIBIN Python
+
+Native C protobuf wire codec with a CPython extension and a small schema registration API. The portable C wire buffer/varint implementation is in `native/core`; `native/python.c` binds Python values. Original PHP/Zend sources under `native/king` are reference only and are not compiled or imported.
+
+```python
+from iibin import Schema
+message = Schema({'text': {'id': 1, 'type': 'string'}})
+message.decode(message.encode({'text': 'Hallo'}))
+```
+
+Install the 2.0 prerelease with `pip install --pre iibin`. `pip install .` builds the extension from source. A C compiler and Python development headers are needed when a wheel is unavailable for your interpreter/platform. `make build` creates a source distribution and a local wheel; see [RELEASING.md](RELEASING.md) for PyPI uploads.
+
+Supported field types: string, bytes, bool, int32/64, uint32/64, sint32/64, fixed32/64, sfixed32/64, float, double, message. Fields may be repeated; nested schemas use `schema`. Numeric repeated fields decode packed and unpacked; encoding is unpacked. Unknown incoming fields are skipped. Absent fields remain absent. Invalid tags, wire mismatches, invalid UTF-8, numeric range violations, non-finite values, nesting above 32 and frames larger than 16 MiB are rejected. Python integers preserve the full 64-bit range.
+
+The JS package has the same wire contract. King enum registries, map/oneof declarations and recursive named schema references are not exposed by these bindings yet. This is not complete API parity with the PHP extension. MIT license.
+
+Source: [iibin-py](https://github.com/Intelligent-Intern/iibin-py). TypeScript codec: [iibin-js](https://github.com/Intelligent-Intern/iibin-js). Lunar Charge Control and Shopfloor demo: [iibin-demo](https://github.com/Intelligent-Intern/iibin-demo).

iibin-2.0.0a1/README.md

@@ -0,0 +1,17 @@
+# IIBIN Python
+
+Native C protobuf wire codec with a CPython extension and a small schema registration API. The portable C wire buffer/varint implementation is in `native/core`; `native/python.c` binds Python values. Original PHP/Zend sources under `native/king` are reference only and are not compiled or imported.
+
+```python
+from iibin import Schema
+message = Schema({'text': {'id': 1, 'type': 'string'}})
+message.decode(message.encode({'text': 'Hallo'}))
+```
+
+Install the 2.0 prerelease with `pip install --pre iibin`. `pip install .` builds the extension from source. A C compiler and Python development headers are needed when a wheel is unavailable for your interpreter/platform. `make build` creates a source distribution and a local wheel; see [RELEASING.md](RELEASING.md) for PyPI uploads.
+
+Supported field types: string, bytes, bool, int32/64, uint32/64, sint32/64, fixed32/64, sfixed32/64, float, double, message. Fields may be repeated; nested schemas use `schema`. Numeric repeated fields decode packed and unpacked; encoding is unpacked. Unknown incoming fields are skipped. Absent fields remain absent. Invalid tags, wire mismatches, invalid UTF-8, numeric range violations, non-finite values, nesting above 32 and frames larger than 16 MiB are rejected. Python integers preserve the full 64-bit range.
+
+The JS package has the same wire contract. King enum registries, map/oneof declarations and recursive named schema references are not exposed by these bindings yet. This is not complete API parity with the PHP extension. MIT license.
+
+Source: [iibin-py](https://github.com/Intelligent-Intern/iibin-py). TypeScript codec: [iibin-js](https://github.com/Intelligent-Intern/iibin-js). Lunar Charge Control and Shopfloor demo: [iibin-demo](https://github.com/Intelligent-Intern/iibin-demo).

iibin-2.0.0a1/RELEASING.md

@@ -0,0 +1,42 @@
+# Publishing to PyPI
+
+```bash
+make build
+.venv/bin/python -m pip install twine
+.venv/bin/python -m twine check --strict dist/*.tar.gz dist/*.whl
+```
+
+Install the wheel into a fresh environment and run the workspace's
+`../interop/check.py` against JavaScript and the rebuilt King extension.
+Also test installation from the source distribution in a fresh environment.
+The extension currently builds interpreter-specific wheels. A local
+`linux_x86_64` wheel is not accepted by PyPI: on Linux, repair and inspect it:
+
+```bash
+.venv/bin/python -m pip install auditwheel patchelf
+mkdir -p dist/release
+PATH="$PWD/.venv/bin:$PATH" .venv/bin/python -m auditwheel repair dist/iibin-2.0.0a1-cp312-cp312-linux_x86_64.whl -w dist/release
+cp dist/iibin-2.0.0a1.tar.gz dist/release/
+.venv/bin/python -m twine check --strict dist/release/*
+```
+
+The example uses CPython 3.12 on Linux x86_64; adapt the wheel name for other
+builds. Produce other platform/interpreter wheels in their matching build
+environments. Other users can build from source with a C compiler and Python
+development headers.
+
+Create a PyPI API token and store it locally in the OS keyring:
+
+```bash
+.venv/bin/python -m keyring set https://upload.pypi.org/legacy/ __token__
+```
+
+Upload only the checked, installation-tested release files:
+
+```bash
+.venv/bin/python -m twine upload --username __token__ dist/release/*
+```
+
+Do not upload the raw local Linux wheel. The version is a prerelease; install
+with `pip install --pre iibin`. PyPI release filenames cannot be reused;
+increase the version for the next release.

iibin-2.0.0a1/native/core/wire.c

@@ -0,0 +1,33 @@
+#include "wire.h"
+#include <stdlib.h>
+#include <string.h>
+int iibin_append(iibin_buffer *b, const void *data, size_t n) {
+    if (n > IIBIN_MAX_BYTES || b->size > IIBIN_MAX_BYTES-n) return 0;
+    size_t needed=b->size+n;
+    if (needed>b->capacity) {
+        size_t cap=b->capacity?b->capacity:128;
+        while(cap<needed) cap*=2;
+        if(cap>IIBIN_MAX_BYTES) cap=IIBIN_MAX_BYTES;
+        void *p=realloc(b->data,cap); if(!p) return 0;
+        b->data=p; b->capacity=cap;
+    }
+    if(n) memcpy(b->data+b->size,data,n);
+    b->size=needed; return 1;
+}
+int iibin_write_varint(iibin_buffer *b, uint64_t v) {
+    unsigned char bytes[10]; size_t n=0;
+    do { bytes[n++]=(unsigned char)((v&127)|(v>127?128:0)); v>>=7; }while(v);
+    return iibin_append(b,bytes,n);
+}
+int iibin_read_varint(const unsigned char *d,size_t n,size_t *p,uint64_t *v) {
+    *v=0;
+    for(unsigned i=0;i<10;i++) {
+        if(*p>=n) return 0;
+        unsigned char c=d[(*p)++];
+        if(i==9 && c>1) return 0;
+        *v|=((uint64_t)(c&127))<<(7*i);
+        if(!(c&128)) return 1;
+    }
+    return 0;
+}
+void iibin_buffer_free(iibin_buffer *b){free(b->data);b->data=NULL;b->size=b->capacity=0;}

iibin-2.0.0a1/native/core/wire.h

@@ -0,0 +1,11 @@
+#ifndef IIBIN_WIRE_H
+#define IIBIN_WIRE_H
+#include <stddef.h>
+#include <stdint.h>
+#define IIBIN_MAX_BYTES (16u * 1024u * 1024u)
+typedef struct { unsigned char *data; size_t size, capacity; } iibin_buffer;
+int iibin_append(iibin_buffer *, const void *, size_t);
+int iibin_write_varint(iibin_buffer *, uint64_t);
+int iibin_read_varint(const unsigned char *, size_t, size_t *, uint64_t *);
+void iibin_buffer_free(iibin_buffer *);
+#endif

iibin-2.0.0a1/native/python.c

@@ -0,0 +1,92 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <math.h>
+#include <string.h>
+#include "wire.h"
+static int error(const char *msg){PyErr_SetString(PyExc_ValueError,msg);return 0;}
+static const char *type_of(PyObject *f){PyObject *t=PyDict_GetItemString(f,"type");return t?PyUnicode_AsUTF8(t):NULL;}
+static int repeated(PyObject *f){PyObject *v=PyDict_GetItemString(f,"repeated");return v&&PyObject_IsTrue(v);}
+static int wire_type(const char *t){if(!strcmp(t,"string")||!strcmp(t,"bytes")||!strcmp(t,"message"))return 2;if(!strcmp(t,"double")||!strcmp(t,"fixed64")||!strcmp(t,"sfixed64"))return 1;if(!strcmp(t,"float")||!strcmp(t,"fixed32")||!strcmp(t,"sfixed32"))return 5;return 0;}
+static int put(iibin_buffer *b,const void *d,size_t n){return iibin_append(b,d,n)||error("Message exceeds 16 MiB or allocation failed");}
+static int varint(iibin_buffer *b,uint64_t v){return iibin_write_varint(b,v)||error("Message exceeds 16 MiB or allocation failed");}
+static int encode_message(PyObject *,PyObject *,iibin_buffer *,int);
+static PyObject *decode_message(PyObject *,const unsigned char *,size_t,int);
+static int number(PyObject *v,const char *t,uint64_t *out){
+    if(!strcmp(t,"bool")){if(!PyBool_Check(v))return error("Expected bool");*out=v==Py_True;return 1;}
+    if(!PyLong_Check(v)||PyBool_Check(v))return error("Expected integer");
+    int uns=!strcmp(t,"uint32")||!strcmp(t,"uint64")||!strcmp(t,"fixed32")||!strcmp(t,"fixed64");
+    if(uns){*out=PyLong_AsUnsignedLongLong(v);if(PyErr_Occurred())return 0;if((strstr(t,"32"))&&*out>UINT32_MAX)return error("Unsigned integer out of range");}
+    else {long long n=PyLong_AsLongLong(v);if(PyErr_Occurred())return 0;if(strstr(t,"32")&&(n<INT32_MIN||n>INT32_MAX))return error("Signed integer out of range");*out=(uint64_t)n;}
+    return 1;
+}
+static int encode_value(PyObject *f,PyObject *v,iibin_buffer *b,int depth){
+    const char *t=type_of(f);if(!t)return 0;int w=wire_type(t);
+    if(w==2){
+        if(!strcmp(t,"message")){iibin_buffer nested={0};int ok=encode_message(PyDict_GetItemString(f,"schema"),v,&nested,depth+1);if(ok)ok=varint(b,nested.size)&&put(b,nested.data,nested.size);iibin_buffer_free(&nested);return ok;}
+        if(!strcmp(t,"string")){if(!PyUnicode_Check(v))return error("Expected string");Py_ssize_t n;const char *s=PyUnicode_AsUTF8AndSize(v,&n);if(!s)return 0;return varint(b,(uint64_t)n)&&put(b,s,(size_t)n);}
+        Py_buffer view;if(PyObject_GetBuffer(v,&view,PyBUF_SIMPLE)<0)return 0;int ok=varint(b,view.len)&&put(b,view.buf,view.len);PyBuffer_Release(&view);return ok;
+    }
+    uint64_t bits=0;
+    if(!strcmp(t,"float")||!strcmp(t,"double")){if(PyBool_Check(v)||(!PyFloat_Check(v)&&!PyLong_Check(v)))return error("Expected finite number");double d=PyFloat_AsDouble(v);if(PyErr_Occurred())return 0;if(!isfinite(d))return error("Non-finite number");if(w==5){float x=(float)d;if(!isfinite(x))return error("Float out of range");uint32_t u;memcpy(&u,&x,4);bits=u;}else memcpy(&bits,&d,8);}
+    else if(!number(v,t,&bits))return 0;
+    if(w==0){if(!strncmp(t,"sint",4))bits=(bits<<1)^((bits>>63)?UINT64_MAX:0);return varint(b,bits);}
+    unsigned char buf[8];size_t count=w==5?4:8;for(size_t i=0;i<count;i++)buf[i]=(unsigned char)(bits>>(8*i));return put(b,buf,count);
+}
+static int encode_message(PyObject *schema,PyObject *obj,iibin_buffer *b,int depth){
+    if(depth>32)return error("Message nesting exceeds 32");if(!PyDict_Check(obj))return error("Message must be a dictionary");
+    PyObject *key,*value;Py_ssize_t pos=0;
+    while(PyDict_Next(obj,&pos,&key,&value))if(!PyDict_Contains(schema,key))return error("Unknown message field");
+    pos=0;
+    while(PyDict_Next(schema,&pos,&key,&value)){
+        PyObject *v=PyDict_GetItemWithError(obj,key);if(!v){if(PyErr_Occurred())return 0;continue;}
+        const char *t=type_of(value);if(!t)return 0;uint64_t tag=(PyLong_AsUnsignedLong(PyDict_GetItemString(value,"id"))<<3)|wire_type(t);
+        if(PyErr_Occurred())return 0;
+        if(repeated(value)){if(!PyList_Check(v)&&!PyTuple_Check(v))return error("Repeated field must be a list or tuple");Py_ssize_t n=PySequence_Size(v);for(Py_ssize_t i=0;i<n;i++){PyObject *item=PySequence_GetItem(v,i);if(!item)return 0;int ok=varint(b,tag)&&encode_value(value,item,b,depth);Py_DECREF(item);if(!ok)return 0;}}
+        else if(!varint(b,tag)||!encode_value(value,v,b,depth))return 0;
+    }return 1;
+}
+static PyObject *decode_value(PyObject *f,const unsigned char *data,size_t n,size_t *pos,int depth){
+    const char *t=type_of(f);if(!t)return NULL;int w=wire_type(t);uint64_t u=0;
+    if(w==2){uint64_t len;if(!iibin_read_varint(data,n,pos,&len)||len>n-*pos){error("Truncated length-delimited field");return NULL;}const unsigned char *s=data+*pos;*pos+=(size_t)len;
+        if(!strcmp(t,"string"))return PyUnicode_DecodeUTF8((const char*)s,(Py_ssize_t)len,"strict");
+        if(!strcmp(t,"bytes"))return PyBytes_FromStringAndSize((const char*)s,(Py_ssize_t)len);
+        return decode_message(PyDict_GetItemString(f,"schema"),s,(size_t)len,depth+1);
+    }
+    if(w==0){if(!iibin_read_varint(data,n,pos,&u)){error("Truncated or overflowing varint");return NULL;}}
+    else {size_t count=w==5?4:8;if(n-*pos<count){error("Truncated fixed-width field");return NULL;}for(size_t i=0;i<count;i++)u|=((uint64_t)data[(*pos)++])<<(8*i);}
+    if(!strcmp(t,"bool"))return PyBool_FromLong(u!=0);
+    if(!strcmp(t,"float")){uint32_t v=(uint32_t)u;float x;memcpy(&x,&v,4);if(!isfinite(x)){error("Non-finite float");return NULL;}return PyFloat_FromDouble(x);}
+    if(!strcmp(t,"double")){double x;memcpy(&x,&u,8);if(!isfinite(x)){error("Non-finite double");return NULL;}return PyFloat_FromDouble(x);}
+    if(!strncmp(t,"sint",4)){if(strstr(t,"32")&&u>UINT32_MAX){error("sint32 out of range");return NULL;}return PyLong_FromLongLong((int64_t)((u>>1)^(uint64_t)-(int64_t)(u&1)));}
+    if(!strcmp(t,"int32")){
+        if(u>INT32_MAX && u<(uint64_t)(int64_t)INT32_MIN){error("int32 out of range");return NULL;}
+        return PyLong_FromLong((int32_t)u);
+    }
+    if(!strcmp(t,"sfixed32"))return PyLong_FromLong((int32_t)u);
+    if(!strcmp(t,"uint32")||!strcmp(t,"fixed32")){if(u>UINT32_MAX){error("uint32 out of range");return NULL;}return PyLong_FromUnsignedLong((uint32_t)u);}
+    if(!strcmp(t,"int64")||!strcmp(t,"sfixed64"))return PyLong_FromLongLong((int64_t)u);
+    return PyLong_FromUnsignedLongLong(u);
+}
+static int skip(const unsigned char *d,size_t n,size_t *p,int w){uint64_t v;if(w==0)return iibin_read_varint(d,n,p,&v);if(w==2){if(!iibin_read_varint(d,n,p,&v)||v>n-*p)return 0;*p+=(size_t)v;return 1;}size_t k=w==1?8:w==5?4:0;if(!k||n-*p<k)return 0;*p+=k;return 1;}
+static PyObject *decode_message(PyObject *schema,const unsigned char *d,size_t n,int depth){
+    if(depth>32){error("Message nesting exceeds 32");return NULL;}
+    PyObject *result=PyDict_New();if(!result)return NULL;size_t p=0;
+    while(p<n){uint64_t tag;if(!iibin_read_varint(d,n,&p,&tag)||tag<8||tag>>3>=((uint64_t)1<<29)){error("Invalid field tag");goto fail;}int w=tag&7;PyObject *key,*field,*found=NULL,*name=NULL;Py_ssize_t it=0;
+        while(PyDict_Next(schema,&it,&key,&field)){unsigned long id=PyLong_AsUnsignedLong(PyDict_GetItemString(field,"id"));if(id==(tag>>3)){found=field;name=key;break;}}
+        if(!found){if(!skip(d,n,&p,w)){error("Invalid unknown field");goto fail;}continue;}
+        const char *t=type_of(found);if(!t)goto fail;int expected=wire_type(t);
+        int packed=w==2&&expected!=2&&repeated(found);size_t packed_end=0;
+        if(packed){uint64_t len;if(!iibin_read_varint(d,n,&p,&len)||len>n-p){error("Truncated packed field");goto fail;}if(!len)continue;packed_end=p+(size_t)len;}
+        PyObject *list=NULL;
+        if(repeated(found)){list=PyDict_GetItemWithError(result,name);if(!list){list=PyList_New(0);if(!list)goto fail;int rc=PyDict_SetItem(result,name,list);Py_DECREF(list);if(rc<0)goto fail;list=PyDict_GetItem(result,name);}}
+        if(packed){while(p<packed_end){PyObject *v=decode_value(found,d,packed_end,&p,depth);if(!v)goto fail;int rc=PyList_Append(list,v);Py_DECREF(v);if(rc<0)goto fail;}continue;}
+        if(w!=expected){error("Field wire type mismatch");goto fail;}
+        PyObject *v=decode_value(found,d,n,&p,depth);if(!v)goto fail;int rc=list?PyList_Append(list,v):PyDict_SetItem(result,name,v);Py_DECREF(v);if(rc<0)goto fail;
+    }return result;
+fail:Py_DECREF(result);return NULL;
+}
+static PyObject *encode(PyObject *self,PyObject *args){(void)self;PyObject *schema,*obj;if(!PyArg_ParseTuple(args,"O!O!",&PyDict_Type,&schema,&PyDict_Type,&obj))return NULL;iibin_buffer b={0};int ok=encode_message(schema,obj,&b,0);PyObject *out=ok?PyBytes_FromStringAndSize((char*)b.data,(Py_ssize_t)b.size):NULL;iibin_buffer_free(&b);return out;}
+static PyObject *decode(PyObject *self,PyObject *args){(void)self;PyObject *schema;Py_buffer view;if(!PyArg_ParseTuple(args,"O!y*",&PyDict_Type,&schema,&view))return NULL;if(view.len>IIBIN_MAX_BYTES){PyBuffer_Release(&view);error("Message exceeds 16 MiB");return NULL;}PyObject *out=decode_message(schema,view.buf,view.len,0);PyBuffer_Release(&view);return out;}
+static PyMethodDef methods[]={{"encode",encode,METH_VARARGS,"Encode schema message in native C."},{"decode",decode,METH_VARARGS,"Decode schema message in native C."},{NULL,NULL,0,NULL}};
+static struct PyModuleDef module={PyModuleDef_HEAD_INIT,"_native",NULL,-1,methods,NULL,NULL,NULL,NULL};
+PyMODINIT_FUNC PyInit__native(void){return PyModule_Create(&module);}

iibin-2.0.0a1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "iibin"
+version = "2.0.0a1"
+description = "Schema-defined IIBIN binary messages with a native C codec"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["iibin", "serialization", "binary", "protobuf", "codec"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: C",
+]
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.urls]
+Repository = "https://github.com/Intelligent-Intern/iibin-py"
+Issues = "https://github.com/Intelligent-Intern/iibin-py/issues"

iibin-2.0.0a1/setup.cfg

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

iibin-2.0.0a1/setup.py

@@ -0,0 +1,10 @@
+import sys
+
+from setuptools import Extension, setup
+
+setup(ext_modules=[Extension(
+    'iibin._native',
+    ['native/python.c', 'native/core/wire.c'],
+    include_dirs=['native/core'],
+    extra_compile_args=['/std:c11', '/W3'] if sys.platform == 'win32' else ['-std=c11', '-Wall', '-Wextra'],
+)])

iibin-2.0.0a1/src/iibin/__init__.py

@@ -0,0 +1,28 @@
+"""Schema-defined protobuf-wire messages. No JSON envelope or content digests."""
+from ._native import encode as _encode, decode as _decode
+
+_TYPES = {'string','bytes','bool','int32','uint32','sint32','int64','uint64','sint64','fixed32','sfixed32','fixed64','sfixed64','float','double','message'}
+
+def _validate(schema, depth=0):
+    if depth > 32 or not isinstance(schema, dict):
+        raise ValueError('Invalid or excessively nested schema')
+    result, ids = {}, set()
+    for name, original in schema.items():
+        f = dict(original)
+        i, t = f.get('id'), f.get('type')
+        if not isinstance(name,str) or not name or type(i) is not int or not 0<i<2**29 or 19000<=i<=19999 or i in ids or t not in _TYPES:
+            raise ValueError(f'Invalid field {name!r}')
+        ids.add(i)
+        if t == 'message': f['schema'] = _validate(f.get('schema'), depth+1)
+        result[name] = f
+    return dict(sorted(result.items(), key=lambda item: item[1]['id']))
+
+class Schema:
+    def __init__(self, fields):
+        self.fields = _validate(fields)
+    def encode(self, message):
+        return _encode(self.fields, message)
+    def decode(self, data):
+        return _decode(self.fields, data)
+
+__all__ = ['Schema']

iibin-2.0.0a1/src/iibin.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: iibin
+Version: 2.0.0a1
+Summary: Schema-defined IIBIN binary messages with a native C codec
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Intelligent-Intern/iibin-py
+Project-URL: Issues, https://github.com/Intelligent-Intern/iibin-py/issues
+Keywords: iibin,serialization,binary,protobuf,codec
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: C
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# IIBIN Python
+
+Native C protobuf wire codec with a CPython extension and a small schema registration API. The portable C wire buffer/varint implementation is in `native/core`; `native/python.c` binds Python values. Original PHP/Zend sources under `native/king` are reference only and are not compiled or imported.
+
+```python
+from iibin import Schema
+message = Schema({'text': {'id': 1, 'type': 'string'}})
+message.decode(message.encode({'text': 'Hallo'}))
+```
+
+Install the 2.0 prerelease with `pip install --pre iibin`. `pip install .` builds the extension from source. A C compiler and Python development headers are needed when a wheel is unavailable for your interpreter/platform. `make build` creates a source distribution and a local wheel; see [RELEASING.md](RELEASING.md) for PyPI uploads.
+
+Supported field types: string, bytes, bool, int32/64, uint32/64, sint32/64, fixed32/64, sfixed32/64, float, double, message. Fields may be repeated; nested schemas use `schema`. Numeric repeated fields decode packed and unpacked; encoding is unpacked. Unknown incoming fields are skipped. Absent fields remain absent. Invalid tags, wire mismatches, invalid UTF-8, numeric range violations, non-finite values, nesting above 32 and frames larger than 16 MiB are rejected. Python integers preserve the full 64-bit range.
+
+The JS package has the same wire contract. King enum registries, map/oneof declarations and recursive named schema references are not exposed by these bindings yet. This is not complete API parity with the PHP extension. MIT license.
+
+Source: [iibin-py](https://github.com/Intelligent-Intern/iibin-py). TypeScript codec: [iibin-js](https://github.com/Intelligent-Intern/iibin-js). Lunar Charge Control and Shopfloor demo: [iibin-demo](https://github.com/Intelligent-Intern/iibin-demo).

iibin-2.0.0a1/src/iibin.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+RELEASING.md
+pyproject.toml
+setup.py
+native/python.c
+native/core/wire.c
+native/core/wire.h
+src/iibin/__init__.py
+src/iibin.egg-info/PKG-INFO
+src/iibin.egg-info/SOURCES.txt
+src/iibin.egg-info/dependency_links.txt
+src/iibin.egg-info/top_level.txt

iibin-2.0.0a1/src/iibin.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

iibin-2.0.0a1/src/iibin.egg-info/top_level.txt

@@ -0,0 +1 @@
+iibin