morphtree 2.1.0__py3-none-win_amd64.whl

morphtree/_installed.py

@@ -0,0 +1,17 @@
+import hashlib,json
+from pathlib import Path
+def activate(file):
+    package=Path(file).resolve().parent
+    m=json.loads((package/'_experimental/manifest.json').read_text('utf8'))
+    actual={p.relative_to(package).as_posix() for p in package.rglob('*') if p.is_file() and '__pycache__' not in p.parts}
+    if actual!=set(m['files'])|{'_experimental/manifest.json'}:raise ImportError('Missing or unexpected installed file')
+    for n,h in m['files'].items():
+        if hashlib.sha256((package/n).read_bytes()).hexdigest()!=h:raise ImportError('Modified installed component: '+n)
+    from .model import MorphTreeClassifier,MorphTreeRegressor,MorphTreeMulticlassClassifier,AutoMorphTree
+    from ._experimental.admission import AdmissionError
+    def denied(*a,**k):raise AdmissionError({'status':'BLOCKED','reason':'INSTALLED_NATIVE_TRAINING_UNQUALIFIED_ZERO_BUDGET'})
+    from ._experimental.execution_v2 import native_fit_entry
+    for cls in (MorphTreeClassifier,MorphTreeRegressor,MorphTreeMulticlassClassifier):cls.fit=native_fit_entry(cls.fit,cls)
+    AutoMorphTree.fit=denied
+    from ._experimental.facade import MorphTree
+    return MorphTree,{'scope':'RESEARCH_ONLY_ZERO_FIT','portable_inference':True,'physical_training':False}

morphtree/_native/__init__.py

@@ -0,0 +1 @@
+"""MorphTree-owned native execution support;no learning rules are selected here."""

morphtree/_native/buffers.py

@@ -0,0 +1,82 @@
+"""Owned compact buffers and a bounded content-keyed tree-layout cache."""
+from array import array
+from collections import OrderedDict
+import ctypes,struct,sys,threading
+from ..scalable_backend import Column
+
+class UnsupportedBuffers(TypeError):pass
+
+TREE_FIELDS=('leaf','values','feature','cut','missing','left','right')
+def address(value):
+    # Never dispatch to an instance/subclass's overridable buffer_info method.
+    return ctypes.c_void_p(array.buffer_info(value)[0])
+
+def columns_view(columns):
+    if type(columns) not in (list,tuple) or not columns:raise ValueError('Nonempty column sequence required')
+    if any(type(c) not in (array,Column) for c in columns):raise UnsupportedBuffers('Exact owned array/Column required')
+    rows=array.__len__(columns[0])
+    if any(c.typecode not in ('B','H','I') or c.itemsize not in (1,2,4) or array.__len__(c)!=rows for c in columns):raise UnsupportedBuffers('Aligned owned B/H/I columns required')
+    widths=array('I',(c.itemsize for c in columns));nominal=array('B',(bool(getattr(c,'nominal',False)) for c in columns))
+    pointers=(ctypes.c_void_p*len(columns))(*(array.buffer_info(c)[0] for c in columns))
+    return dict(rows=rows,widths=widths,nominal=nominal,pointers=pointers,owners=(*columns,widths,nominal))
+
+def tree_key(nodes):
+    if type(nodes) not in (list,tuple):raise UnsupportedBuffers('Exact owned node list/tuple required')
+    if not nodes:raise ValueError('Nonempty declarative tree required')
+    # Include type and all numeric bits. True/1,-0/+0 and NaN payloads must not
+    # accidentally alias a previously checked layout. A changed tuple/list or
+    # even an intentional frozen-dataclass bypass produces a different key.
+    key=[]
+    for n in nodes:
+        if type(n.is_leaf) is not bool or type(n.missing_left) is not bool:raise ValueError('Typed tree flags required')
+        ints=(n.feature,n.threshold_bin,n.left,n.right)
+        if any(type(v) is not int or not -(2**63)<=v<2**63 for v in ints):raise ValueError('Int64 tree fields required')
+        key.append((n.is_leaf,struct.pack('=d',n.value),*ints,n.missing_left))
+    return tuple(key)
+
+def pack_tree(key):
+    leaf=array('B');values=array('d');feature=array('q');cut=array('q');missing=array('B');left=array('q');right=array('q')
+    for is_leaf,value,f,c,l,r,m in key:
+        leaf.append(is_leaf);values.append(struct.unpack('=d',value)[0]);feature.append(f);cut.append(c);left.append(l);right.append(r);missing.append(m)
+    return dict(zip(TREE_FIELDS,(leaf,values,feature,cut,missing,left,right)))
+
+def owned_bytes(key,packed):
+    # Conservative accounting includes key containers and scalar references,
+    # even when CPython interns/shares them. No input columns/models retained.
+    return (sys.getsizeof(key)+sum(sys.getsizeof(row)+sum(sys.getsizeof(v) for v in row) for row in key)
+            +sys.getsizeof(packed)+sum(sys.getsizeof(v) for v in packed.values())+256)
+
+class TreeCache:
+    def __init__(self,max_bytes=4*1024**2):
+        if type(max_bytes) is not int or max_bytes<0:raise ValueError('Nonnegative cache byte allowance')
+        self.max_bytes=max_bytes;self.bytes=0;self.hits=0;self.misses=0;self.evictions=0;self._data=OrderedDict();self._lock=threading.RLock()
+    def prepare(self,nodes):
+        key=tree_key(nodes)
+        with self._lock:
+            if key in self._data:
+                self.hits+=1;packed,size=self._data.pop(key);self._data[key]=(packed,size);return packed
+            self.misses+=1;packed=pack_tree(key);size=owned_bytes(key,packed)
+            if size<=self.max_bytes:
+                while self._data and self.bytes+size>self.max_bytes:
+                    _,(_,old)=self._data.popitem(last=False);self.bytes-=old;self.evictions+=1
+                self._data[key]=(packed,size);self.bytes+=size
+            return packed
+    def clear(self):
+        with self._lock:self._data.clear();self.bytes=0
+    def report(self):
+        with self._lock:return dict(bytes_accounted=self.bytes,max_bytes=self.max_bytes,entries=len(self._data),hits=self.hits,misses=self.misses,evictions=self.evictions,scope='Conservative Python object accounting;not measured RSS')
+
+def histogram_view(column,indices,g,h,r,u,size):
+    if type(size) is not int or not 1<=size<=sys.maxsize//40:raise ValueError('Safe positive bin count required')
+    if type(column) not in (array,Column) or column.typecode not in ('B','H','I') or column.itemsize not in (1,2,4):raise UnsupportedBuffers('Exact owned bin array/Column required')
+    values=(g,h,r,u)
+    if any(type(v) is not array or v.typecode!='d' or v.itemsize!=8 or array.__len__(v)!=array.__len__(column) for v in values):raise UnsupportedBuffers('Exact aligned binary64 arrays required')
+    copied=not (type(indices) is array and indices.typecode=='Q' and indices.itemsize==8)
+    if copied:
+        if type(indices) not in (list,tuple,range,array):raise UnsupportedBuffers('Exact bounded node indices required')
+        ids=array('Q')
+        for i in indices:
+            if type(i) is not int or not 0<=i<array.__len__(column):raise ValueError('Invalid row index')
+            ids.append(i)
+    else:ids=indices
+    return dict(ids=ids,owners=(column,ids,*values),copy_bytes=len(ids)*8 if copied else 0)

morphtree/_native/loader.py

@@ -0,0 +1,39 @@
+"""Load only the installed package's hash-bound library;never compile at import."""
+import ctypes,hashlib,json,platform,struct,sys,threading
+from pathlib import Path
+from .runtime import Runtime
+_LOCK=threading.RLock();_RUNTIME=None;_INFO=None
+def platform_key():
+    if struct.calcsize('P')!=8 or platform.machine().lower() not in ('amd64','x86_64'):raise ImportError('This native build requires64bit x86_64')
+    if sys.platform=='win32':return 'win_amd64'
+    if sys.platform.startswith('linux'):return 'linux_x86_64'
+    raise ImportError('No qualified native artifact for this operating system')
+def artifact():
+    root=Path(__file__).resolve().parent;manifest=root/'manifest.json'
+    if not manifest.is_file():raise ImportError('Native library missing:install the matching experimental wheel or build from source with an existing C toolchain')
+    v=json.loads(manifest.read_text('utf8'));expected={'schema','ABI','platform','library','binary_sha256','sources','floating_point','runtime_compilation','build_settings'}
+    if type(v) is not dict or set(v)!=expected or v['schema']!='MORPHTREE_NATIVE_ABI_1' or v['ABI']!=1 or v['platform']!=platform_key() or v['runtime_compilation'] is not False:raise ImportError('Native artifact capability mismatch')
+    name='morphtree_kernels.dll' if sys.platform=='win32' else 'libmorphtree_kernels.so'
+    if v['library']!='bin/'+v['platform']+'/'+name or set(v['sources'])!={'src/histogram.c','src/traversal.c'}:raise ImportError('Unexpected native artifact path/source contract')
+    p=root/v['library']
+    for item in (p,*p.parents):
+        if not item.is_relative_to(root):break
+        if item.is_symlink() or getattr(item,'is_junction',lambda:False)():raise ImportError('Native paths cannot be links')
+    if not p.is_file() or hashlib.sha256(p.read_bytes()).hexdigest()!=v['binary_sha256']:raise ImportError('Native binary integrity failure')
+    for n,h in v['sources'].items():
+        source=root/n
+        if source.is_symlink() or not source.is_file() or hashlib.sha256(source.read_bytes()).hexdigest()!=h:raise ImportError('Native source integrity failure')
+    return p,v
+def get_runtime():
+    global _RUNTIME,_INFO
+    with _LOCK:
+        if _RUNTIME is None:
+            p,v=artifact()
+            # Retain GIL;Windows lookup uses the verified DLL directory and
+            # standard loader directories,never the current working directory.
+            library=ctypes.PyDLL(str(p),winmode=0x1100) if sys.platform=='win32' else ctypes.PyDLL(str(p),mode=ctypes.RTLD_LOCAL)
+            _RUNTIME=Runtime(library);_INFO=v
+        return _RUNTIME
+def runtime_info():
+    get_runtime()
+    return dict(platform=_INFO['platform'],binary_sha256=_INFO['binary_sha256'],ABI=_INFO['ABI'],runtime_compilation=False,cache=_RUNTIME.trees.report())

morphtree/_native/manifest.json

@@ -0,0 +1,29 @@
+{
+  "ABI": 1,
+  "binary_sha256": "1c577f636a74d873942d31ab81a1278eda8096252531c52520d00db2471d2a14",
+  "build_settings": {
+    "CRT": "static /MT",
+    "compiler_sha256": "b0a1818ebae6da7f18230a84e76ce839212584ac4c2ab55b97a0d5268085da57",
+    "flags": [
+      "/nologo",
+      "/LD",
+      "/std:c11",
+      "/W4",
+      "/WX",
+      "/O2",
+      "/fp:strict",
+      "/MT",
+      "/Brepro"
+    ],
+    "setup_sha256": "6b516d8fcf543c14b2d861e1f45661e0029230fe0dc48e86ce78522801822209"
+  },
+  "floating_point": "binary64 ordered / strict,without reassociation or contracted multiply-add",
+  "library": "bin/win_amd64/morphtree_kernels.dll",
+  "platform": "win_amd64",
+  "runtime_compilation": false,
+  "schema": "MORPHTREE_NATIVE_ABI_1",
+  "sources": {
+    "src/histogram.c": "4b05c05dab1de35c2b8c7cee69cf743b51f746e1d0a14b782df73d3ce959bf39",
+    "src/traversal.c": "487d8ca46c96faded18d99dcda0abcb3c8a0fa783070a7da23dd5692a7a69406"
+  }
+}

morphtree/_native/runtime.py

@@ -0,0 +1,48 @@
+"""Integrated ABI execution;immutable keys,per-call buffers and retained GIL."""
+from array import array
+from contextlib import ExitStack
+import ctypes
+from .buffers import TreeCache,columns_view,histogram_view,TREE_FIELDS,address,UnsupportedBuffers
+from ..scalable_backend import Column
+
+class Runtime:
+    def __init__(self,histogram_library,traversal_library=None,*,cache_bytes=4*1024**2):
+        # The loader,not a model packet,chooses and verifies these handles.
+        self.histogram_library=histogram_library;self.traversal_library=traversal_library or histogram_library
+        self.histogram_library.mt_histogram_abi_version.restype=ctypes.c_uint32
+        self.traversal_library.mt_traversal_abi_version.restype=ctypes.c_uint32
+        if self.histogram_library.mt_histogram_abi_version()!=1 or self.traversal_library.mt_traversal_abi_version()!=1:raise ImportError('Unsupported MorphTree native ABI')
+        f=self.histogram_library.mt_histogram_f64_v1;f.argtypes=[ctypes.c_void_p,ctypes.c_uint32,ctypes.c_uint64,ctypes.c_void_p,ctypes.c_uint64,*([ctypes.c_void_p]*4),ctypes.c_uint64,ctypes.c_void_p,ctypes.c_uint64];f.restype=ctypes.c_int;self.histogram_function=f
+        f=self.traversal_library.mt_predict_tree_f64_v1;f.argtypes=[ctypes.c_void_p]*3+[ctypes.c_uint64]*2+[ctypes.c_void_p]*7+[ctypes.c_uint64,ctypes.c_void_p,ctypes.c_uint64];f.restype=ctypes.c_int;self.traversal_function=f
+        self.trees=TreeCache(cache_bytes)
+    def histogram(self,column,indices,g,h,r,u,size):
+        # Pin caller-owned arrays before validating lengths or running any
+        # conversion. Concurrent resize must not invalidate a checked shape.
+        if type(column) not in (array,Column) or any(type(v) is not array for v in (g,h,r,u)):
+            raise UnsupportedBuffers('Exact owned bin and statistic arrays required')
+        with ExitStack() as pins:
+            for value in (column,g,h,r,u):pins.enter_context(memoryview(value))
+            if type(indices) is array:pins.enter_context(memoryview(indices))
+            p=histogram_view(column,indices,g,h,r,u,size);owners=p['owners']
+            pins.enter_context(memoryview(p['ids']))
+            output=array('d',[0.])*(5*size)
+            pointers=[address(v) for v in owners]
+            code=self.histogram_function(pointers[0],column.itemsize,array.__len__(column),pointers[1],array.__len__(p['ids']),*pointers[2:],size,address(output),len(output))
+            if code:raise ValueError('Native histogram rejected request/status='+str(code))
+            from ..scalable_backend import Hist
+            return Hist([output[i*size:(i+1)*size] for i in range(5)],getattr(column,'nominal',False)),p['copy_bytes']
+    def predict_tree(self,nodes,columns):
+        if type(columns) not in (list,tuple) or not columns:raise ValueError('Nonempty column sequence required')
+        columns=tuple(columns)
+        if any(type(c) not in (array,Column) for c in columns):raise UnsupportedBuffers('Exact owned array/Column required')
+        # Snapshot the container and pin columns before nominal.__bool__ or
+        # a node value's numeric conversion can execute Python callbacks.
+        with ExitStack() as pins:
+            for value in columns:pins.enter_context(memoryview(value))
+            c=columns_view(columns);p=self.trees.prepare(nodes)
+            for value in (c['widths'],c['nominal'],*(p[k] for k in TREE_FIELDS)):
+                pins.enter_context(memoryview(value))
+            output=array('d',[0.])*c['rows'];pointer=address
+            code=self.traversal_function(c['pointers'],pointer(c['widths']),pointer(c['nominal']),len(columns),c['rows'],*(pointer(p[k]) for k in TREE_FIELDS),array.__len__(p['leaf']),pointer(output),len(output))
+            if code:raise ValueError('Native traversal rejected request/status='+str(code))
+            return list(output)

morphtree/_native/src/histogram.c

@@ -0,0 +1,61 @@
+/* MorphTree-owned prototype: ordered five-plane histogram, ABI v1.
+ * No scoring policy, split rule, sampling, tree growth or learner is compiled
+ * into this primitive. Caller supplies stable owned buffers; output never aliases
+ * an input. No fast-math, reassociation or reduction reordering is permitted.
+ * SOURCE ONLY until a real compiler/build/test result is recorded.
+ */
+#include <stddef.h>
+#include <stdint.h>
+#include <float.h>
+#include <string.h>
+
+_Static_assert(sizeof(double) == 8 && DBL_MANT_DIG == 53 && FLT_RADIX == 2,
+               "MorphTree histogram ABI requires binary64 doubles");
+_Static_assert(sizeof(size_t) == 8, "Prototype currently qualified for 64-bit ABI only");
+
+#if defined(_WIN32)
+#define MT_EXPORT __declspec(dllexport)
+#else
+#define MT_EXPORT __attribute__((visibility("default")))
+#endif
+
+enum { MT_OK=0, MT_BAD_ARGUMENT=1, MT_BAD_INDEX=2, MT_BAD_BIN=3, MT_OVERFLOW=4 };
+
+MT_EXPORT uint32_t mt_histogram_abi_version(void) { return 1u; }
+
+static uint32_t read_bin(const void *bins, uint32_t width, uint64_t row) {
+    /* memcpy also avoids alignment/aliasing undefined behavior at the ABI edge. */
+    if (width == 1u) return ((const uint8_t *)bins)[row];
+    if (width == 2u) { uint16_t v; memcpy(&v, (const uint8_t *)bins + row*2u, 2u); return v; }
+    { uint32_t v; memcpy(&v, (const uint8_t *)bins + row*4u, 4u); return v; }
+}
+
+MT_EXPORT int mt_histogram_f64_v1(
+        const void *bins, uint32_t width, uint64_t rows,
+        const uint64_t *ids, uint64_t selected,
+        const double *g, const double *h, const double *r, const double *u,
+        uint64_t bin_count, double *out, uint64_t output_doubles) {
+    if ((width!=1u && width!=2u && width!=4u) || bin_count==0u || !out)
+        return MT_BAD_ARGUMENT;
+    if (bin_count > SIZE_MAX/(5u*sizeof(double)) || rows > SIZE_MAX/width)
+        return MT_OVERFLOW;
+    if (output_doubles < 5u*bin_count) return MT_BAD_ARGUMENT;
+    if (selected && (!bins || !ids || !g || !h || !r || !u)) return MT_BAD_ARGUMENT;
+    /* Validate first: ordinary invalid requests do not alter the output.
+     * The Python prototype retains the GIL and buffer exports throughout. */
+    for (uint64_t k=0; k<selected; ++k) {
+        const uint64_t i=ids[k];
+        if (i>=rows) return MT_BAD_INDEX;
+        if (read_bin(bins,width,i)>=bin_count) return MT_BAD_BIN;
+    }
+    memset(out,0,(size_t)(5u*bin_count*sizeof(double)));
+    double *counts=out, *gs=out+bin_count, *hs=out+2u*bin_count;
+    double *rs=out+3u*bin_count, *us=out+4u*bin_count;
+    for (uint64_t k=0; k<selected; ++k) {
+        const uint64_t i=ids[k];
+        const uint32_t b=read_bin(bins,width,i);
+        counts[b]+=1.0;
+        gs[b]+=g[i]; hs[b]+=h[i]; rs[b]+=r[i]; us[b]+=u[i];
+    }
+    return MT_OK;
+}

morphtree/_native/src/traversal.c

@@ -0,0 +1,51 @@
+/* MorphTree-owned traversal ABI1:read an existing declarative tree only.
+ * No training,split policy or program selection is encoded here.
+ * Stable owned nonaliasing caller buffers;bounded traversal even for cycles.
+ */
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include <float.h>
+_Static_assert(sizeof(size_t)==8 && sizeof(double)==8 && DBL_MANT_DIG==53,"64bit binary64 ABI required");
+#if defined(_WIN32)
+#define MT_EXPORT __declspec(dllexport)
+#else
+#define MT_EXPORT __attribute__((visibility("default")))
+#endif
+MT_EXPORT uint32_t mt_traversal_abi_version(void){return 1u;}
+static uint32_t bin_at(const void *column,uint32_t width,uint64_t row){
+    if(width==1u)return ((const uint8_t*)column)[row];
+    if(width==2u){uint16_t v;memcpy(&v,(const uint8_t*)column+row*2u,2u);return v;}
+    {uint32_t v;memcpy(&v,(const uint8_t*)column+row*4u,4u);return v;}
+}
+MT_EXPORT int mt_predict_tree_f64_v1(
+    const void *const *columns,const uint32_t *widths,const uint8_t *nominal,
+    uint64_t features,uint64_t rows,const uint8_t *leaf,const double *values,
+    const int64_t *feature,const int64_t *cut,const uint8_t *missing_left,
+    const int64_t *left,const int64_t *right,uint64_t nodes,double *out,uint64_t output_size){
+    if(!features || !nodes || nodes>INT64_MAX || rows>SIZE_MAX/8u || output_size<rows
+       || !columns || !widths || !nominal || !leaf || !values || !feature || !cut
+       || !missing_left || !left || !right || (rows && !out))return 1;
+    for(uint64_t f=0;f<features;f++){
+        if((widths[f]!=1u && widths[f]!=2u && widths[f]!=4u) || nominal[f]>1u
+           || rows>SIZE_MAX/widths[f] || (rows && !columns[f]))return 1;
+    }
+    /* Validate every index before any possible column/node read. */
+    for(uint64_t k=0;k<nodes;k++){
+        if(leaf[k]>1u || missing_left[k]>1u)return 1;
+        if(!leaf[k] && (feature[k]<0 || (uint64_t)feature[k]>=features || cut[k]<0
+           || (uint64_t)cut[k]>UINT32_MAX || left[k]<0 || right[k]<0
+           || (uint64_t)left[k]>=nodes || (uint64_t)right[k]>=nodes))return 2;
+    }
+    for(uint64_t row=0;row<rows;row++){
+        uint64_t k=0;int reached=0;
+        for(uint64_t hop=0;hop<=nodes;hop++){
+            if(leaf[k]){out[row]=values[k];reached=1;break;}
+            uint64_t f=(uint64_t)feature[k];uint32_t b=bin_at(columns[f],widths[f],row);
+            int go_left=nominal[f] ? b==(uint32_t)cut[k] : b==0u ? missing_left[k] : b<=(uint32_t)cut[k];
+            k=(uint64_t)(go_left ? left[k] : right[k]);
+        }
+        if(!reached)return 3; /* Cyclic graph,no unbounded native loop. */
+    }
+    return 0;
+}