morphtree 2.1.0__py3-none-win_amd64.whl

morphtree/_experimental/numeric_fixture.py

@@ -0,0 +1,21 @@
+"""Explicit software driver, never an Optuna study/trial or a fit."""
+from types import SimpleNamespace
+
+
+def module(fault=None):
+    class Trial:
+        def __init__(self,number):self.number=number
+        def suggest_int(self,name,low,high):return low+1+self.number
+        def suggest_float(self,name,low,high,log=False):return low if self.number==0 else high
+    class Study:
+        def __init__(self):self.n=0
+        def ask(self):
+            if fault=='ask':raise RuntimeError('SIMULATED_ASK_FAILURE')
+            trial=Trial(self.n);self.n+=1;return trial
+        def tell(self,*a,**k):
+            if fault=='tell':raise RuntimeError('SIMULATED_TELL_FAILURE')
+    class Sampler:
+        def __init__(self,**kwargs):self.parameters=kwargs
+    return SimpleNamespace(samplers=SimpleNamespace(TPESampler=Sampler),
+        trial=SimpleNamespace(TrialState=SimpleNamespace(FAIL='SIMULATED_FAIL')),
+        create_study=lambda **kwargs:Study())

morphtree/_experimental/parameter_contract.py

@@ -0,0 +1,38 @@
+"""Research-only numeric-space admission, reusing actual native activity rules.
+
+Potentially active is not guaranteed sensitive on every dataset. Frozen topology,
+binning and learning-budget dimensions are not final numeric opportunities here.
+No historical tuning space or production API is modified.
+"""
+from dataclasses import asdict,fields
+from morphtree.config import AlgorithmGenome,HyperParams
+
+FROZEN={'max_depth','max_leaves','max_bins','n_estimators'}
+
+def schema(family,task,genome):
+    if family not in ('boost','bag') or task not in ('binary','multiclass','regression') or not isinstance(genome,AlgorithmGenome):raise ValueError('Explicit native family/task/genome')
+    if task!='binary' and genome!=AlgorithmGenome():raise ValueError('Current native nonbinary API supports fixed Base genome only')
+    active=set(genome.active_parameters());known={f.name for f in fields(HyperParams)};frozen=set(FROZEN)
+    if family=='bag':
+        frozen.add('learning_rate')
+        # Reset members have one stage: decay multiplies iteration0, hence zero.
+        active.discard('update_decay')
+    return {name:{'status':'INACTIVE' if name not in active else 'FROZEN_FORM_OR_BUDGET' if name in frozen else 'POTENTIALLY_ACTIVE','condition':'AlgorithmGenome.active_parameters + fixed-form/budget boundary','data_dependent':True} for name in sorted(known)}
+
+def admit_space(space,*,family,task,genome,drop_inactive=False):
+    if not isinstance(space,dict) or not space or type(drop_inactive) is not bool:raise ValueError('Nonempty explicit future space')
+    rules=schema(family,task,genome);accepted={};excluded={}
+    for name,spec in space.items():
+        if name not in rules:raise ValueError('Unknown parameter: '+str(name))
+        status=rules[name]['status']
+        if status=='FROZEN_FORM_OR_BUDGET':raise ValueError('Structural/budget dimension is frozen: '+name)
+        if status=='INACTIVE':
+            if not drop_inactive:raise ValueError('Inactive under actual genome: '+name)
+            excluded[name]='INACTIVE_UNDER_FROZEN_GENOME';continue
+        if type(spec) not in (list,tuple) or len(spec)!=2:raise ValueError('Bound pair required')
+        lo,hi=spec
+        if type(lo) not in (int,float) or type(hi) not in (int,float) or not lo<hi:raise ValueError('Increasing finite native parameter bounds')
+        for v in (lo,hi):HyperParams(**(asdict(HyperParams())|{name:v}))
+        accepted[name]=list(spec)
+    if not accepted:raise ValueError('No active numeric opportunity remains')
+    return {'space':accepted,'excluded':excluded,'mode':'RESEARCH_ONLY_NOT_INSTALLED_OR_HISTORICAL_SPACE_CHANGE'}

morphtree/_experimental/postfit.py

@@ -0,0 +1,51 @@
+"""Existing safe-loader/V3/standalone sequence for a returned installed model.
+
+No training or selector here; actual pre-save observations are persisted first.
+"""
+import json
+import time
+from pathlib import Path
+from .admission import digest,sha
+from .runtime_io import artifact_path,reference
+from .base import Base
+from .target import _NamedRows
+from . import roundtrip_v3 as v3
+
+
+def finish(session,model,root,raw):
+    session.check();query={'rows':raw['predict_X'],'names':raw['names']}
+    X=_NamedRows(query['rows'],query['names']);obj=model._variant('selected')
+    def behavior(m):
+        value={'prediction':m.predict(X)}
+        if m.task_!='regression':value['probabilities']=m.predict_proba(X)
+        return value
+    before=behavior(obj);t0=time.perf_counter_ns();source_sha=digest(session.source)
+    pre=root/'PRE-SAVE-WITNESS.json'
+    pre.write_text(json.dumps({'before':before,'query':query,'source_sha256':source_sha,'captured_before_save':t0},sort_keys=True)+'\n',encoding='utf8')
+    p=root/'NATIVE-BEFORE.json';obj.save(p);t1=time.perf_counter_ns()
+    loaded=Base.load(p);t2=time.perf_counter_ns();after=behavior(loaded);t3=time.perf_counter_ns()
+    q=root/'NATIVE-AFTER.json';loaded.save(q)
+    a,b=p.read_bytes(),q.read_bytes();sa,sb=json.loads(a),json.loads(b)
+    runtime=session.engine.identity;recipe=digest(obj.best_recipe_);loader=sha(session.engine.package/'model.py')
+    witness={'schema':'morph032-actual-behavior-v1','runtime':runtime,'source_sha256':source_sha,'recipe_sha256':recipe,
+        'query':query,'loader_sha256':loader,'before_state_sha256':digest(sa),'after_state_sha256':digest(sb),
+        'before':before,'after':after,'events':dict(zip(('captured_before_save','saved','safe_loaded','captured_after_load'),(t0,t1,t2,t3)))}
+    trust={'runtime':runtime,'actual_runtime':runtime,'before_sha256':sha(p),'after_sha256':sha(q),'witness_sha256':digest(witness),
+        'query_sha256':digest(query),'source_sha256':source_sha,'recipe_sha256':recipe,'loader_sha256':loader,
+        'admission':('QUALIFIED_RETAINED_ZERO_FIT' if session.mode=='PUBLIC_POSTFIT_IO' else
+            'QUALIFIED_COMP003_LIVE_COMPONENTS' if session.mode=='LIVE' else 'QUALIFIED_COMP003_SOFTWARE')}
+    comparison=v3.compare(a,b,trust=trust,witness=witness)
+    (root/'V3.json').write_text(json.dumps({'result':comparison,'witness':witness,'trust':trust},sort_keys=True,indent=2)+'\n',encoding='utf8')
+    if comparison['status']!='PASS':raise ValueError('V3 failed: '+str(comparison))
+    path=root/'MODEL.json';model.save(path)
+    from .integrated import MorphTree
+    restored=MorphTree.load(path,sha256=sha(path),workdir=session.root)
+    if behavior(restored)!=before or restored.recipe()!=model.recipe():raise ValueError('Actual final wrapper/recipe changed')
+    program=root/'PREDICTOR.py';restored.export_python(program)
+    from .worker import standalone
+    value={'program':{'path':'PREDICTOR.py','sha256':sha(program),'bytes':program.stat().st_size},'expected':before,'query':query}
+    result=standalone(root,value,session.check)
+    session.check()
+    return {'model':reference(path),'program':reference(program),'expected':before,'query':query,
+        'V3':reference(root/'V3.json'),'standalone':result,'task':model.task_,'family':model.best_family_,
+        'scope':session.mode,'report':model.report(),'counts':session.counters()}

morphtree/_experimental/preprocessing.py

@@ -0,0 +1,133 @@
+"""Bounded TRAIN-local schema shared by the public runtime and standalone export.
+
+String categoricals use sorted one-hot columns plus separate missing/unseen
+channels. Numeric missing values stay None for the native missing split rule.
+No optional dependency is imported. pandas.NA is recognized only when pandas is
+already loaded by the caller. Each validation fold needs its own instance.
+"""
+import copy
+import math
+import sys
+from numbers import Real
+
+
+def _m26_missing(v):
+    if v is None:
+        return True
+    if isinstance(v, Real):
+        return math.isnan(float(v))
+    # Never evaluate NA's truth value or import pandas in a standalone runtime.
+    pandas = sys.modules.get('pandas')
+    return pandas is not None and v is getattr(pandas, 'NA', None)
+
+
+def _m26_scalar(v):
+    if _m26_missing(v):
+        return None
+    if isinstance(v, str):
+        if len(v) > 1024:
+            raise ValueError('Category string exceeds 1024 characters')
+        return v
+    if isinstance(v, Real):
+        z = float(v)
+        if math.isfinite(z):
+            return z
+    raise ValueError('Expected finite numeric, string category, None, numeric NaN or pandas.NA; infinity/objects are unsupported')
+
+
+def _m26_rows(X):
+    names = list(X.columns) if hasattr(X, 'columns') else None
+    if hasattr(X, 'to_numpy'):
+        X = X.to_numpy()
+    if hasattr(X, 'tolist'):
+        X = X.tolist()
+    if not isinstance(X, (list, tuple)) or not 1 <= len(X) <= 100000:
+        raise ValueError('X must be a nonempty dense 2D table, at most 100000 rows')
+    if not isinstance(X[0], (list, tuple)) or not 1 <= len(X[0]) <= 4096:
+        raise ValueError('X must have 1..4096 columns')
+    n = len(X[0])
+    if len(X)*n > 2000000 or any(not isinstance(r, (list, tuple)) or len(r) != n for r in X):
+        raise ValueError('Rectangular X required, at most 2000000 input cells')
+    if names is not None and (len(names) != n or any(not isinstance(v, str) or not v or len(v)>1024 for v in names) or len(set(names)) != n):
+        raise ValueError('Unique nonempty string column names required')
+    return [[_m26_scalar(v) for v in r] for r in X], names
+
+
+class TrainEncoder:
+    """Immutable-by-copy serializable schema; fit accepts TRAIN rows only."""
+    def fit(self, X):
+        rows, names = _m26_rows(X)
+        columns = []
+        for col in zip(*rows):
+            present = [v for v in col if v is not None]
+            if any(isinstance(v, str) for v in present):
+                if any(not isinstance(v, str) for v in present):
+                    raise ValueError('Mixed numeric/string column; supply a consistent type')
+                vocab = sorted(set(present))
+                if len(vocab) > 64:
+                    raise ValueError('Experimental categorical vocabulary cap is 64 per TRAIN column')
+                columns.append({'kind': 'categorical', 'vocabulary': vocab})
+            else:
+                columns.append({'kind': 'numeric'})
+        state = {'schema': 'morph026-train-encoder-v1', 'names': names, 'columns': columns}
+        checked = self.from_dict(state)  # Validate before replacing a fitted schema.
+        self.state_, self.width_ = checked.state_, checked.width_
+        return self
+
+    def to_dict(self):
+        if not hasattr(self, 'state_'):
+            raise RuntimeError('Encoder is not fitted')
+        return copy.deepcopy(self.state_)
+
+    @classmethod
+    def from_dict(cls, state):
+        if type(state) is not dict or set(state) != {'schema', 'names', 'columns'} or state['schema'] != 'morph026-train-encoder-v1':
+            raise ValueError('Exact encoder schema required')
+        cols, names = state['columns'], state['names']
+        if type(cols) is not list or not 1 <= len(cols) <= 4096:
+            raise ValueError('Bounded column schema required')
+        if names is not None and (type(names) is not list or len(names)!=len(cols) or any(not isinstance(n,str) or not n or len(n)>1024 for n in names) or len(set(names))!=len(names)):
+            raise ValueError('Invalid column names')
+        width = 0
+        for c in cols:
+            if c == {'kind': 'numeric'}:
+                width += 1
+            elif type(c) is dict and set(c)=={'kind','vocabulary'} and c['kind']=='categorical':
+                v = c['vocabulary']
+                if type(v) is not list or not 1<=len(v)<=64 or any(not isinstance(s,str) or len(s)>1024 for s in v) or v!=sorted(set(v)):
+                    raise ValueError('Bounded canonical TRAIN vocabulary required')
+                width += len(v)+2
+            else:
+                raise ValueError('Unknown encoder column rule')
+        if width>4096:
+            raise ValueError('Encoded feature cap is 4096')
+        obj=cls(); obj.state_=copy.deepcopy(state); obj.width_=width
+        return obj
+
+    def transform(self, X):
+        s=self.to_dict(); rows,names=_m26_rows(X)
+        if len(rows[0])!=len(s['columns']):
+            raise ValueError('Missing or extra input columns')
+        if s['names'] is not None:
+            if names is None or set(names)!=set(s['names']):
+                raise ValueError('Named training schema requires the same named columns')
+            order=[names.index(n) for n in s['names']]
+            rows=[[r[i] for i in order] for r in rows]
+        elif names is not None:
+            raise ValueError('Training used positional columns; named prediction input is ambiguous')
+        result=[]
+        for row in rows:
+            out=[]
+            for value,c in zip(row,s['columns']):
+                if c['kind']=='numeric':
+                    if isinstance(value,str):
+                        raise ValueError('String supplied to numeric TRAIN column')
+                    out.append(value)
+                else:
+                    if value is not None and not isinstance(value,str):
+                        raise ValueError('Numeric supplied to string categorical column')
+                    vocab=c['vocabulary']; z=[0.0]*(len(vocab)+2)
+                    i=len(vocab) if value is None else vocab.index(value) if value in vocab else len(vocab)+1
+                    z[i]=1.0;out.extend(z)
+            result.append(out)
+        return result

morphtree/_experimental/processes.py

@@ -0,0 +1,191 @@
+import os,stat,time,signal,subprocess
+from pathlib import Path
+from contextlib import contextmanager
+from .runtime_io import artifact_path
+class ContinuityError(ValueError):
+    """Invalid plan, changed evidence, or an unsafe recovery request."""
+
+class LockBusy(ContinuityError):
+    """Another live supervisor owns this state directory."""
+
+def _safe(path):
+    path = Path(os.path.abspath(path))
+    for item in reversed((path, *path.parents)):
+        try:
+            info = item.lstat()
+        except FileNotFoundError:
+            continue
+        if stat.S_ISLNK(info.st_mode) or getattr(info, 'st_file_attributes', 0) & 1024:
+            raise ContinuityError('Symlinks and reparse points are forbidden')
+    return path
+
+def _artifact(path):
+    try:
+        return artifact_path(path)
+    except ValueError as exc:
+        raise ContinuityError(str(exc)) from exc
+
+@contextmanager
+def exclusive_lock(state_dir):
+    """Advisory kernel lock; closure or process death releases ownership."""
+    root = _artifact(state_dir)
+    root.mkdir(parents=True, exist_ok=True)
+    path = _safe(root / '.lock')
+    with path.open('a+b') as stream:
+        if path.stat().st_size == 0:
+            stream.write(b'\x00')
+            stream.flush()
+        stream.seek(0)
+        try:
+            if os.name == 'nt':
+                import msvcrt
+                msvcrt.locking(stream.fileno(), msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError as exc:
+            raise LockBusy('Another live supervisor owns the state directory') from exc
+        try:
+            yield root
+        finally:
+            stream.seek(0)
+            if os.name == 'nt':
+                import msvcrt
+                msvcrt.locking(stream.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(stream.fileno(), fcntl.LOCK_UN)
+
+class ChildGuard:
+    """Windows job kills descendants on parent death; POSIX uses a process group."""
+
+    def __init__(self, child, *, memory_limits=None):
+        self.child = child
+        self.job = None
+        self._owned_pids = {child.pid}
+        self._working_set_peaks = {}
+        self.memory_limits = memory_limits
+        if memory_limits is not None:
+            if os.name != 'nt' or type(memory_limits) is not dict or set(memory_limits) != {'process_commit_bytes', 'job_commit_bytes'} or any((type(v) is not int or v < 32 * 1024 ** 2 for v in memory_limits.values())) or (memory_limits['process_commit_bytes'] > memory_limits['job_commit_bytes']):
+                if child.poll() is None:
+                    child.kill()
+                child.wait()
+                raise ContinuityError('Windows private-commit memory profile unavailable/invalid; not an RSS limit')
+        if os.name == 'nt':
+            import ctypes
+            from ctypes import wintypes
+
+            class Basic(ctypes.Structure):
+                _fields_ = [('PerProcessUserTimeLimit', ctypes.c_int64), ('PerJobUserTimeLimit', ctypes.c_int64), ('LimitFlags', wintypes.DWORD), ('MinimumWorkingSetSize', ctypes.c_size_t), ('MaximumWorkingSetSize', ctypes.c_size_t), ('ActiveProcessLimit', wintypes.DWORD), ('Affinity', ctypes.c_size_t), ('PriorityClass', wintypes.DWORD), ('SchedulingClass', wintypes.DWORD)]
+
+            class IO(ctypes.Structure):
+                _fields_ = [(name, ctypes.c_uint64) for name in ('ReadOperationCount', 'WriteOperationCount', 'OtherOperationCount', 'ReadTransferCount', 'WriteTransferCount', 'OtherTransferCount')]
+
+            class Extended(ctypes.Structure):
+                _fields_ = [('BasicLimitInformation', Basic), ('IoInfo', IO), ('ProcessMemoryLimit', ctypes.c_size_t), ('JobMemoryLimit', ctypes.c_size_t), ('PeakProcessMemoryUsed', ctypes.c_size_t), ('PeakJobMemoryUsed', ctypes.c_size_t)]
+
+            class Accounting(ctypes.Structure):
+                _fields_ = [(name, ctypes.c_int64) for name in ('TotalUserTime', 'TotalKernelTime', 'ThisPeriodTotalUserTime', 'ThisPeriodTotalKernelTime')] + [(name, wintypes.DWORD) for name in ('TotalPageFaultCount', 'TotalProcesses', 'ActiveProcesses', 'TotalTerminatedProcesses')]
+            kernel = ctypes.WinDLL('kernel32', use_last_error=True)
+            kernel.CreateJobObjectW.argtypes = [ctypes.c_void_p, wintypes.LPCWSTR]
+            kernel.CreateJobObjectW.restype = wintypes.HANDLE
+            kernel.SetInformationJobObject.argtypes = [wintypes.HANDLE, ctypes.c_int, ctypes.c_void_p, wintypes.DWORD]
+            kernel.AssignProcessToJobObject.argtypes = [wintypes.HANDLE, wintypes.HANDLE]
+            kernel.IsProcessInJob.argtypes = [wintypes.HANDLE, wintypes.HANDLE, ctypes.POINTER(wintypes.BOOL)]
+            kernel.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
+            kernel.OpenProcess.restype = wintypes.HANDLE
+            kernel.TerminateJobObject.argtypes = [wintypes.HANDLE, wintypes.UINT]
+            kernel.QueryInformationJobObject.argtypes = [wintypes.HANDLE, ctypes.c_int, ctypes.c_void_p, wintypes.DWORD, ctypes.c_void_p]
+            kernel.CloseHandle.argtypes = [wintypes.HANDLE]
+            self.kernel = kernel
+            self.accounting = Accounting
+            self.extended = Extended
+            self.job = kernel.CreateJobObjectW(None, None)
+            limit = Extended()
+            limit.BasicLimitInformation.LimitFlags = 8192
+            if memory_limits is not None:
+                limit.BasicLimitInformation.LimitFlags |= 256 | 512
+                limit.ProcessMemoryLimit = memory_limits['process_commit_bytes']
+                limit.JobMemoryLimit = memory_limits['job_commit_bytes']
+            if not self.job or not kernel.SetInformationJobObject(self.job, 9, ctypes.byref(limit), ctypes.sizeof(limit)) or (not kernel.AssignProcessToJobObject(self.job, int(child._handle))):
+                if self.job:
+                    kernel.CloseHandle(self.job)
+                    self.job = None
+                child.kill()
+                child.wait()
+                raise ContinuityError('Cannot establish Windows process-tree cleanup job')
+
+    def statistics(self):
+        """Owned Job accounting only. Commit peaks are NOT RSS/working-set peaks."""
+        if self.job is None:
+            return {'scope': 'UNAVAILABLE', 'job_private_commit_peak_bytes': None, 'CPU_job_seconds': None}
+        import ctypes
+        limit = self.extended()
+        account = self.accounting()
+        if not self.kernel.QueryInformationJobObject(self.job, 9, ctypes.byref(limit), ctypes.sizeof(limit), None) or not self.kernel.QueryInformationJobObject(self.job, 1, ctypes.byref(account), ctypes.sizeof(account), None):
+            raise ContinuityError('Cannot verify owned Job limits/accounting')
+        actual = {'process_commit_bytes': int(limit.ProcessMemoryLimit), 'job_commit_bytes': int(limit.JobMemoryLimit)}
+        flags = int(limit.BasicLimitInformation.LimitFlags)
+        if self.memory_limits is not None and (actual != self.memory_limits or flags & 768 != 768):
+            raise ContinuityError('Owned Job memory limits differ')
+        from ctypes import wintypes
+
+        class Memory(ctypes.Structure):
+            _fields_ = [('cb', wintypes.DWORD), ('PageFaultCount', wintypes.DWORD)] + [(n, ctypes.c_size_t) for n in ('PeakWorkingSetSize', 'WorkingSetSize', 'QuotaPeakPagedPoolUsage', 'QuotaPagedPoolUsage', 'QuotaPeakNonPagedPoolUsage', 'QuotaNonPagedPoolUsage', 'PagefileUsage', 'PeakPagefileUsage', 'PrivateUsage')]
+        psapi = ctypes.WinDLL('psapi', use_last_error=True)
+        psapi.GetProcessMemoryInfo.argtypes = [wintypes.HANDLE, ctypes.c_void_p, wintypes.DWORD]
+        for pid in self._owned_pids:
+            handle = self.kernel.OpenProcess(1024 | 16, False, pid)
+            if not handle:
+                continue
+            try:
+                member = wintypes.BOOL()
+                if not self.kernel.IsProcessInJob(handle, self.job, ctypes.byref(member)) or not member.value:
+                    continue
+                memory = Memory()
+                memory.cb = ctypes.sizeof(memory)
+                if psapi.GetProcessMemoryInfo(handle, ctypes.byref(memory), ctypes.sizeof(memory)):
+                    self._working_set_peaks[pid] = max(self._working_set_peaks.get(pid, 0), int(memory.PeakWorkingSetSize))
+            finally:
+                self.kernel.CloseHandle(handle)
+        return {'scope': 'WINDOWS_OWNED_JOB_PRIVATE_COMMIT_NOT_RSS', 'memory_limits': actual, 'private_commit_allocation_policy_verified': self.memory_limits is not None, 'hard_private_commit_cap_verified': False, 'hard_peak_private_commit_cap': False, 'peak_over_job_policy_bytes': max(0, int(limit.PeakJobMemoryUsed) - actual['job_commit_bytes']) if self.memory_limits else None, 'memory_boundary': 'Configured Windows allocation policy;observed refusal is not proof of an absolute peak ceiling', 'job_private_commit_peak_bytes': int(limit.PeakJobMemoryUsed), 'process_private_commit_peak_bytes': int(limit.PeakProcessMemoryUsed), 'CPU_job_seconds': (account.TotalUserTime + account.TotalKernelTime) / 10000000.0, 'active_processes': int(account.ActiveProcesses), 'total_processes': int(account.TotalProcesses), 'owned_process_peak_working_sets_bytes': dict(self._working_set_peaks), 'working_set_scope': 'Sampled OS-maintained peaks of verified owned launcher/worker PIDs;not aggregate job RSS', 'peak_RSS': 'NOT_A_PORTABLE_OR_AGGREGATE_RSS_MEASURE', 'aggregate_RSS_cap': False}
+
+    def include_pid(self, pid):
+        """Also attach an interpreter already started by a Windows venv launcher."""
+        if self.job is None:
+            return
+        import ctypes
+        from ctypes import wintypes
+        handle = self.kernel.OpenProcess(256 | 1 | 4096, False, pid)
+        if not handle:
+            raise ContinuityError('Cannot identify the bootstrap interpreter')
+        try:
+            member = wintypes.BOOL()
+            if not self.kernel.IsProcessInJob(handle, self.job, ctypes.byref(member)):
+                raise ContinuityError('Cannot verify bootstrap job membership')
+            if not member.value and (not self.kernel.AssignProcessToJobObject(self.job, handle)):
+                raise ContinuityError('Cannot attach bootstrap interpreter to cleanup job')
+            self._owned_pids.add(pid)
+        finally:
+            self.kernel.CloseHandle(handle)
+
+    def close(self):
+        if self.job is not None:
+            import ctypes
+            self.kernel.TerminateJobObject(self.job, 1)
+            deadline = time.monotonic() + 5
+            while time.monotonic() < deadline:
+                counters = self.accounting()
+                if not self.kernel.QueryInformationJobObject(self.job, 1, ctypes.byref(counters), ctypes.sizeof(counters), None) or counters.ActiveProcesses == 0:
+                    break
+                time.sleep(0.01)
+            self.kernel.CloseHandle(self.job)
+            self.job = None
+        elif os.name != 'nt':
+            try:
+                os.killpg(self.child.pid, signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+        if self.child.poll() is None:
+            self.child.kill()
+        self.child.wait()