jwwkit 0.2.0__py3-none-any.whl

jwwkit/_geometry_math.py

@@ -0,0 +1,93 @@
+"""Analytic two-dimensional primitives; no drawing/GUI or external implementation."""
+import math
+
+TAU = 2 * math.pi
+IDENTITY = (1., 0., 0., 1., 0., 0.)
+
+
+def finite(value):
+    if type(value) not in (int, float) or not math.isfinite(value): raise ValueError('Nonfinite/non-numeric geometry value')
+    return value
+
+
+def point(matrix, x, y):
+    x, y = finite(x), finite(y); a,b,c,d,tx,ty = matrix
+    return [finite(a*x+b*y+tx), finite(c*x+d*y+ty)]
+
+
+def compose(parent, child):
+    a,b,c,d,x,y = parent; e,f,g,h,u,v = child
+    return tuple(finite(z) for z in (a*e+b*g, a*f+b*h, c*e+d*g, c*f+d*h, a*u+b*v+x, c*u+d*v+y))
+
+
+def block_matrix(r):
+    sx,sy,angle,x,y = [finite(r[k]) for k in ('scale_x','scale_y','rotation','ref_x','ref_y')]
+    if sx == 0 or sy == 0: raise ValueError('Zero block scale has unverified geometry')
+    cs,sn = math.cos(angle),math.sin(angle)
+    return (sx*cs,-sy*sn,sx*sn,sy*cs,x,y), abs(sx) == abs(sy)
+
+
+def bounds(points):
+    for p in points:
+        for v in p:finite(v)
+    return [min(p[0] for p in points),min(p[1] for p in points),max(p[0] for p in points),max(p[1] for p in points)]
+
+
+def union(boxes):
+    return [min(b[0] for b in boxes),min(b[1] for b in boxes),max(b[2] for b in boxes),max(b[3] for b in boxes)]
+
+
+def arc_point(center, radius, angle):
+    return [finite(center[0]+radius*math.cos(angle)),finite(center[1]+radius*math.sin(angle))]
+
+
+def on_sweep(angle, start, sweep):
+    if abs(sweep) >= TAU: return True
+    delta = (angle-start) % TAU if sweep >= 0 else (start-angle) % TAU
+    return delta <= abs(sweep) or abs(delta-TAU) <= 8*math.ulp(TAU)
+
+
+def arc_bounds(center, radius, start, sweep):
+    pts = [arc_point(center,radius,start),arc_point(center,radius,start+sweep)]
+    pts.extend(arc_point(center,radius,a) for a in (0.,math.pi/2,math.pi,3*math.pi/2) if on_sweep(a,start,sweep))
+    return bounds(pts)
+
+
+def cross(a,b,c):
+    return (b[0]-a[0])*(c[1]-a[1])-(b[1]-a[1])*(c[0]-a[0])
+
+
+def polygon(points):
+    clean=[]
+    for p in points:
+        if not clean or p != clean[-1]: clean.append(p)
+    if len(clean)>1 and clean[0]==clean[-1]: clean.pop()
+    if len(clean)<3 or len(set(map(tuple,clean)))!=len(clean): raise ValueError('Degenerate solid polygon')
+    for i in range(len(clean)):
+        a,b=clean[i],clean[(i+1)%len(clean)]
+        for j in range(i+1,len(clean)):
+            if j==i+1 or i==0 and j==len(clean)-1:continue
+            c,d=clean[j],clean[(j+1)%len(clean)]
+            if cross(a,b,c)*cross(a,b,d)<=0 and cross(c,d,a)*cross(c,d,b)<=0:
+                if max(min(a[0],b[0]),min(c[0],d[0]))<=min(max(a[0],b[0]),max(c[0],d[0])) and max(min(a[1],b[1]),min(c[1],d[1]))<=min(max(a[1],b[1]),max(c[1],d[1])):
+                    raise ValueError('Self-intersecting/ambiguous solid perimeter')
+    weights=[clean[i][0]*clean[(i+1)%len(clean)][1]-clean[(i+1)%len(clean)][0]*clean[i][1] for i in range(len(clean))]
+    twice=finite(sum(weights))
+    if twice==0:raise ValueError('Zero-area solid polygon')
+    centroid=[sum((clean[i][k]+clean[(i+1)%len(clean)][k])*weights[i] for i in range(len(clean)))/(3*twice) for k in (0,1)]
+    return clean,[finite(v)for v in centroid],'ccw' if twice>0 else 'cw'
+
+
+def segment_distance(p,a,b):
+    dx,dy=b[0]-a[0],b[1]-a[1];n=dx*dx+dy*dy
+    t=max(0.,min(1.,((p[0]-a[0])*dx+(p[1]-a[1])*dy)/n)) if n else 0.
+    return math.hypot(p[0]-a[0]-t*dx,p[1]-a[1]-t*dy)
+
+
+def polygon_distance(p,vertices,boundary=False):
+    distance=min(segment_distance(p,a,b) for a,b in zip(vertices,vertices[1:]+vertices[:1]))
+    if boundary or distance==0:return distance
+    inside=False
+    for a,b in zip(vertices,vertices[1:]+vertices[:1]):
+        if (a[1]>p[1])!=(b[1]>p[1]) and p[0] < a[0]+(p[1]-a[1])*(b[0]-a[0])/(b[1]-a[1]):inside=not inside
+    return 0. if inside else distance

jwwkit/_normalization_inspection.py

@@ -0,0 +1,83 @@
+"""Read-only, bounded schema inspection. No class-byte scanning or file writes."""
+from pathlib import Path
+import hashlib,struct
+from jwwkit.reader.archive import Cursor,_read_records,read_records_bytes
+from jwwkit.writer.preserved import serialize_body
+from jwwkit.model.rigid_audit import exact
+
+CLASSES=frozenset(('CDataSen','CDataEnko','CDataMoji'))
+MAX_FILE_BYTES=268435456
+MAX_BATCH_BYTES=536870912
+MAX_FILES=256
+
+def sha(data):return hashlib.sha256(data).hexdigest()
+
+def _roundtrip(raw,parsed,zero=False):
+    for encoding in (('cp932','utf-16le')if parsed['version']==600 else ('utf-16le','cp932')):
+        try:
+            body=serialize_body(parsed['entities'],parsed['block_defs'],parsed['version'],encoding=encoding,
+                raw_trailer=parsed['raw_trailer'],class_declarations=parsed['class_declarations']if zero else None)
+            if raw[:parsed['header_end']]+body==raw:return
+        except (ValueError,UnicodeError,struct.error):pass
+    raise ValueError('Unedited serialization is not byte-identical')
+
+def _observe(raw):
+    c=Cursor(raw);c.schema_profile='rebro_schema0';c.class_declarations=[];observed=[]
+    def observer(name,schema,offset,index):
+        observed.append(dict(name=name.decode('ascii',errors='backslashreplace'),name_bytes_hex=name.hex(),schema=schema,
+            declaration_offset=offset,schema_offset=offset+2,class_index=index))
+    c._class_declaration_observer=observer
+    try:return _read_records(c),observed,None,c.pos,c.context
+    except (ValueError,UnicodeError,struct.error,OverflowError)as exc:return None,observed,str(exc),c.pos,c.context
+
+def inspect_bytes(raw,source):
+    version=struct.unpack_from('<I',raw,8)[0]if len(raw)>=12 and raw[:8]==b'JwwData.'else None
+    base=dict(source=str(source),source_sha256=sha(raw),size=len(raw),version=version,status='unsupported',
+        declarations=[],changed_declarations=[],unsupported_declarations=[],enumeration_complete=False,
+        inspection_stopped_offset=None,uninspected_bytes=0,reason=None,expected_output_sha256=None)
+    try:
+        parsed=read_records_bytes(raw);_roundtrip(raw,parsed)
+        base.update(status='not_needed',reason='already_standard',enumeration_complete=True,
+            declarations=[dict(name=d['name'],schema=d['schema'],declaration_offset=d['offset'],schema_offset=d['offset']+2,class_index=d['class_index'])for d in parsed['class_declarations']])
+        return base,None
+    except (ValueError,UnicodeError,struct.error,OverflowError)as strict_error:
+        base['strict_reason']=str(strict_error)
+    parsed,observed,error,offset,context=_observe(raw)
+    base['declarations']=observed
+    base['unsupported_declarations']=[dict(d,reason='outside_observed_three_class_schema0_scope')for d in observed if d['name']not in CLASSES or d['schema']!=0]
+    if parsed is None:
+        base.update(reason=error,inspection_stopped_offset=offset,uninspected_bytes=max(0,len(raw)-offset),context=context)
+        return base,None
+    try:
+        _roundtrip(raw,parsed,True)
+        if version not in (600,700)or not observed or any(d['name']not in CLASSES or d['schema']!=0 for d in observed):raise ValueError('Not an observed schema0 input')
+        output=bytearray(raw);changed=[]
+        for d in observed:
+            p=d['schema_offset']
+            if raw[p-2:p]!=b'\xff\xff'or struct.unpack_from('<H',raw,p)[0]!=0:raise ValueError('Class declaration identity changed')
+            replacement=struct.pack('<H',version);output[p:p+2]=replacement
+            changed.append(dict(d,before=0,after=version,before_bytes_hex=raw[p:p+2].hex(),after_bytes_hex=replacement.hex()))
+        output=bytes(output);normal=read_records_bytes(output);_roundtrip(output,normal)
+        for field in ('entities','block_defs','raw_trailer','version','header_end','memo','layer_names','color_names','line_type_names'):
+            if not exact(parsed[field],normal[field]):raise ValueError('Normalization changed parsed field: '+field)
+        positions={x['schema_offset']+j for x in changed for j in (0,1)}
+        if len(raw)!=len(output)or any(a!=b and i not in positions for i,(a,b)in enumerate(zip(raw,output))):raise ValueError('Changes outside approved schema words')
+        if any(x['schema']!=version for x in normal['class_declarations']):raise ValueError('Output schema is not the file version')
+        base.update(status='normalize',reason='observed_schema0_only',enumeration_complete=True,changed_declarations=changed,
+            expected_output_sha256=sha(output),verification=dict(original_roundtrip=True,strict_output_roundtrip=True,all_element_fields_equal=True,non_schema_bytes_equal=True))
+        return base,output
+    except (ValueError,UnicodeError,struct.error,OverflowError)as exc:
+        base.update(reason=str(exc),enumeration_complete=True)
+        return base,None
+
+def inspect_path(source):
+    path=Path(source).resolve()
+    try:
+        if not path.is_file():raise ValueError('Source must be a regular file')
+        with path.open('rb')as stream:raw=stream.read(MAX_FILE_BYTES+1)
+        if len(raw)>MAX_FILE_BYTES:raise ValueError('Source exceeds 256 MiB inspection limit')
+        return inspect_bytes(raw,path)
+    except (OSError,ValueError)as exc:
+        return dict(source=str(path),status='error',reason=str(exc),exception_type=type(exc).__name__,
+            source_sha256=None,size=None,version=None,declarations=[],changed_declarations=[],unsupported_declarations=[],
+            enumeration_complete=False,inspection_stopped_offset=None,uninspected_bytes=None,expected_output_sha256=None),None

jwwkit/_replacement_contract.py

@@ -0,0 +1,161 @@
+"""Strict recipe and independent result checks for the observed replacement scope."""
+from pathlib import Path
+import copy,hashlib,math
+from jwwkit.cad_model import CadDocument
+from jwwkit.alignment import solve_two_point_alignment
+from jwwkit.writer.preserved import _document_bytes
+from jwwkit.model.group_import import global_settings_bytes
+from jwwkit.workflow_settings import _verify_resolved,_hash,_copy,_canonical,_assert_live_snapshot
+
+def require(ok,message):
+    if not ok:raise ValueError(message)
+def group(value):
+    require(type(value)is int and 0<=value<16,'Group must be integer 0..15')
+    return value
+
+def reference_rows(doc):
+    from jwwkit.safe_edit import entity_view
+    return [dict(index=i,real_mm=list(doc.convert_point((e.geometry['x'],e.geometry['y']),layer_group=3,from_units='paper',to_units='real')),element=entity_view(e))
+     for i,e in enumerate(doc.entities)if e.entity_type=='POINT'and e.attributes['layer_group']==3 and e.attributes['layer']==0
+     and e.geometry['is_temporary']and e.geometry['code']==0]
+
+def points(doc,indices):
+    rows={r['index']:r for r in reference_rows(doc)}
+    require(type(indices)is list and len(indices)==2 and all(type(i)is int and i in rows for i in indices)and len(set(indices))==2,'Two distinct group3/layer0 temporary-point indices required')
+    return [rows[i]['real_mm']for i in indices]
+
+def archive_candidates(cad,building):
+    counts={g:0 for g in range(16)}
+    for r in cad._source_records['entities']:counts[r['base']['layer_group']]+=1
+    result=[]
+    for g in range(16):
+        h=cad.header['layer_groups'][g]
+        reason='target_group'if g==building else 'reference_group'if g==3 else 'writing'if h['state']==3 else 'protected'if h['protect']else 'occupied'if counts[g]else None
+        result.append(dict(group=g,root_count=counts[g],state=h['state'],protected=h['protect'],eligible=reason is None,reason=reason))
+    return result
+
+def _contents(cad):
+    from jwwkit.safe_edit import snapshot
+    snap=snapshot(cad)
+    return dict(snap,entities=[r['record']for r in snap['entities']])
+
+BASE_CONTEXT={'incoming','building_group','source_reference_indices','target_reference_indices','distance_tolerance','angle_tolerance','angle_units','settings_policy'}
+
+def prepare(cad,new,settings,context,*,verification=False):
+    """Simulate in memory only. Never select a replacement group during execution."""
+    from jwwkit.safe_edit import _targets,_apply_edit_actions
+    settings=_verify_resolved(settings);context=_copy(context)
+    require(set(context)==BASE_CONTEXT|({'archive_group','archive_selection'}if verification else set()),'Unknown/incomplete replacement context')
+    building=group(context['building_group']);require(building!=3,'Building and reference group must differ')
+    require(cad.version==new.version==700,'Replacement workflow supports observed v700 scope only')
+    require(context['incoming']==str(Path(new.source).resolve()),'Incoming context path mismatch')
+    require(context['settings_policy']in ('strict','destination'),'Invalid settings_policy')
+    for doc in (cad,new):
+        require(doc.get_group_state(building)['raw_value']!=3,'Writing building group cannot be replaced/imported')
+        require(not doc.header['layer_groups'][building]['protect'],'Protected building group')
+        require(doc.get_group_scale(building)==100,'Replacement requires both original building scales 1/100')
+        _document_bytes(doc)
+    old=list(cad.find_entities(layer_group=building));added=list(new.find_entities(layer_group=building))
+    require(old and added,'Both building groups must be nonempty')
+    require(not any(doc.entities[i].entity_type=='BLOCK'for doc,ids in ((cad,old),(new,added))for i in ids),'Building references are outside this replacement workflow scope')
+    for doc,indices in ((cad,old),(new,added)):
+        for i in indices:
+            e=doc.entities[i];text=e.geometry if e.entity_type=='TEXT'else e.geometry.get('text',{})if e.entity_type=='DIMENSION'else {}
+            require(not text.get('content','').startswith('^@BM'),'Image-dependent building elements are unsupported, including delete mode')
+    kw=dict(source_points=points(new,context['source_reference_indices']),target_points=points(cad,context['target_reference_indices']),
+      distance_tolerance=context['distance_tolerance'],angle_tolerance=context['angle_tolerance'],angle_units=context['angle_units'],allow_scale=False)
+    fit=solve_two_point_alignment(**kw);require(fit['passed']and fit['applied_scale']==1,'Alignment exceeds explicit tolerances or changes scale')
+    fit['measured_endpoint_displacement_mm']=2*fit['source_distance_mm']*math.sin(abs(fit['angle_difference_rad'])/2)
+    mode=settings['effective']['old_group_action'];request=settings['effective']['archive_group'];chosen=None;selection=[]
+    if mode=='archive':
+        require(request is not None,'Archive group must be specified in config, instruction or plan argument')
+        candidates=archive_candidates(cad,building);eligible=[r['group']for r in candidates if r['eligible']]
+        if verification:
+            chosen=group(context['archive_group'])
+            require(chosen in eligible,'Fixed archive group is no longer empty/eligible; never select another group')
+            require(chosen==(min(eligible)if request=='first_empty'else request),'Archive selection proof changed')
+        else:
+            require(eligible,'No eligible empty archive group')
+            chosen=min(eligible)if request=='first_empty'else group(request)
+            require(chosen in eligible,'Specified archive group must be empty, non-writing, unprotected and distinct')
+        selection=candidates if request=='first_empty'else [candidates[chosen]]
+    if verification:
+        require(context['archive_group']==chosen and context['archive_selection']==selection,'Fixed archive context changed')
+    else:context.update(archive_group=chosen,archive_selection=selection)
+    excluded={building,chosen}if mode=='archive'else{building}
+    protected={str(g):cad.snapshot_group(g)for g in range(16)if g not in excluded}
+    actions=[]
+    if mode=='archive':
+        if cad.get_group_scale(chosen)!=100:actions.append(dict(op='set_group_scale',kwargs=dict(layer_group=chosen,scale=100)))
+        actions.extend([dict(op='set_entity_attributes',indices=old,kwargs=dict(layer_group=chosen,preserve='paper')),
+                        dict(op='set_group_state',kwargs=dict(layer_group=chosen,state='hidden'))])
+    actions.extend([dict(op='import_group',**{'as':'incoming'},kwargs=dict(path=context['incoming'],source_group=building,target_group=building,
+                   sync_scale=False,sync_group_name=False,sync_layer_names=False,settings_policy=context['settings_policy'])),
+                   dict(op='align_two_points',indices=['incoming'],kwargs=kw)])
+    if mode=='delete':actions.append(dict(op='delete_entities',indices=old,kwargs={}))
+    targets=_targets(cad,old);stage=copy.deepcopy(cad);imports=[]
+    _apply_edit_actions(stage,dict(actions=actions,targets=targets),import_results=imports)
+    from jwwkit.writer.preserved import entity_record
+    from jwwkit.model.rigid_audit import exact,audit_records
+    originals=[e for i,e in enumerate(cad.entities)if mode=='archive'or i not in old]
+    survivors=[e for e in stage.entities if e.source_index is not None]
+    require([e.source_index for e in survivors]==[e.source_index for e in originals],'Original survivor order/population changed')
+    old_ids={cad.entities[i].source_index for i in old}
+    for before,after in zip(originals,survivors):
+        expected=copy.deepcopy(entity_record(before))
+        if mode=='archive'and before.source_index in old_ids:expected['base']['layer_group']=chosen
+        require(exact(expected,entity_record(after)),'An original element changed beyond the declared archive group')
+    imported_records=[entity_record(e)for e in stage.entities if e.source_index is None]
+    require(len(imported_records)==len(added)and len(stage.entities)==len(originals)+len(added),'Imported/deleted element counts disagree')
+    tr=fit['transform']
+    rigid=audit_records([entity_record(new.entities[i])for i in added],imported_records,
+      base_point_real=tr['base_point'],translation_real=tr['translation'],rotation=tr['rotation'],group_scale=100,
+      definition_mapping=imports[0]['receipt']['definition_mapping'])
+    require(rigid['passed'],'Incoming rigid geometry or exact attributes changed')
+    require(global_settings_bytes(cad)==global_settings_bytes(stage,_document_bytes(stage)),'Destination global settings bytes changed')
+    audits={g:stage.audit_group_unchanged(int(g),snap)for g,snap in protected.items()}
+    require(all(a['passed']for a in audits.values()),'A non-target group changed')
+    data=_document_bytes(stage)
+    review=dict(old_group_action=mode,old_count=len(old),archived_count=len(old)if mode=='archive'else 0,
+      deleted_count=len(old)if mode=='delete'else 0,added_count=len(added),expected_entity_count=len(stage.entities),
+      old_target_indices=old,old_targets_sha256=_hash(targets),deleted_target_indices=old if mode=='delete'else [],
+      expected_contents_sha256=_hash(_contents(stage)),expected_output_sha256=hashlib.sha256(data).hexdigest(),
+      global_settings_sha256=hashlib.sha256(global_settings_bytes(cad)).hexdigest(),alignment=fit,incoming_rigid_audit=rigid,
+      layer_name_differences=[dict(layer=l,old=cad.get_layer_name(building,l),incoming=new.get_layer_name(building,l))for l in range(16)if cad.get_layer_name(building,l)!=new.get_layer_name(building,l)],
+      protected_groups=protected)
+    return dict(context=context,actions=actions,targets=targets,review=_copy(review))
+
+def validate_plan(cad,plan,*,planning=False):
+    w=plan['workflow'];require(type(w)is dict and set(w)=={'schema_version','name','settings','context','review'},'Invalid workflow record keys')
+    require(type(w['schema_version'])is int and w['schema_version']==1 and w['name']=='building_replacement','Unsupported workflow')
+    require(_hash(w)==plan['workflow_sha256'],'Workflow hash mismatch')
+    settings=_verify_resolved(w['settings'])
+    if planning:_assert_live_snapshot(settings)
+    new=CadDocument.open(w['context']['incoming'])
+    proof=prepare(cad,new,settings,w['context'],verification=True)
+    require(_canonical(proof['actions'])==_canonical(plan['actions']),'Workflow settings and edit actions disagree')
+    require(proof['targets']==plan['targets'],'Workflow old targets changed')
+    require(_canonical(proof['review'])==_canonical(w['review']),'Workflow review/evidence changed')
+    require(plan['selection']is None or [h['index']for h in plan['selection']['hits']]==proof['review']['old_target_indices'],'Workflow selection mismatch')
+    cfg=Path(settings['config_snapshot']['config_path'])
+    for p in (plan['output'],str(Path(plan['output']).with_suffix('.changes.json'))):require(Path(p).resolve()!=cfg,'Output overlaps workflow configuration')
+    require(cfg.resolve()not in {Path(d['path']).resolve()for d in plan['dependencies']},'Mutable config must be frozen in plan, not a live dependency')
+    return proof
+
+def audit_result(after,plan):
+    from jwwkit.safe_edit import file_sha256
+    require(file_sha256(plan['source'])==plan['source_sha256'],'Source changed during workflow')
+    for dep in plan['dependencies']:require(file_sha256(dep['path'])==dep['sha256'],'Workflow input dependency changed')
+    original=CadDocument.open(plan['source']);proof=validate_plan(original,plan)
+    review=proof['review'];context=proof['context'];mode=review['old_group_action']
+    require(_hash(_contents(after))==review['expected_contents_sha256'],'Replacement result contents differ from approved projection')
+    serialized=_document_bytes(after)
+    require(hashlib.sha256(serialized).hexdigest()==review['expected_output_sha256'],'Replacement output bytes differ from approved projection')
+    groups={g:after.audit_group_unchanged(int(g),snap)for g,snap in review['protected_groups'].items()}
+    require(all(a['passed']for a in groups.values()),'Saved non-target group changed')
+    require(hashlib.sha256(global_settings_bytes(after,serialized)).hexdigest()==review['global_settings_sha256'],'Saved global settings changed')
+    if mode=='archive':
+        chosen=context['archive_group'];require(after.get_group_state(chosen)['raw_value']==0 and after.get_group_scale(chosen)==100,'Archive state/scale mismatch')
+        require(len(after.find_entities(layer_group=chosen))==review['old_count'],'Archive count mismatch')
+    return dict(passed=True,old_group_action=mode,archive_group=context['archive_group'],archived_count=review['archived_count'],deleted_count=review['deleted_count'],
+                added_count=review['added_count'],non_target_groups=groups,global_settings_preserved=True,output_sha256=review['expected_output_sha256'])

jwwkit/_resources.py

@@ -0,0 +1,23 @@
+"""Access data installed alongside jwwkit."""
+from importlib.resources import files
+from pathlib import Path
+
+
+def _installed_path(*parts: str) -> Path:
+    path = files("jwwkit").joinpath(*parts)
+    if not isinstance(path, Path):
+        raise RuntimeError("Install jwwkit with pip to obtain persistent file paths")
+    return path
+
+
+def template_path() -> Path:
+    """Return the installed empty JWW template, for opening read-only."""
+    return _installed_path("resources", "empty_template.jww")
+
+
+def guide_paths() -> dict[str, Path]:
+    """Return the installed paths of AGENTS.md and the Japanese usage guide."""
+    return {
+        "agents": _installed_path("guides", "AGENTS.md"),
+        "usage_guide": _installed_path("guides", "docs", "usage_guide.md"),
+    }

jwwkit/_spatial_distance.py

@@ -0,0 +1,95 @@
+"""Analytic distances to qualified U2 logical geometry. Never infer missing shapes."""
+import math
+from jwwkit._geometry_math import finite,arc_point,on_sweep,cross
+
+
+def segment(p,a,b):
+    dx,dy=finite(b[0]-a[0]),finite(b[1]-a[1]);length=finite(math.hypot(dx,dy))
+    if length==0:return finite(math.dist(p,a))
+    ux,uy=dx/length,dy/length
+    along=finite(finite(p[0]-a[0])*ux+finite(p[1]-a[1])*uy)
+    if along<=0:return finite(math.dist(p,a))
+    if along>=length:return finite(math.dist(p,b))
+    return finite(abs(finite(p[0]-a[0])*uy-finite(p[1]-a[1])*ux))
+
+
+def polygon(p,vertices):
+    edges=list(zip(vertices,vertices[1:]+vertices[:1]))
+    d=min(segment(p,a,b)for a,b in edges)
+    if d==0:return 0.
+    inside=False
+    for a,b in edges:
+        if (a[1]>p[1])!=(b[1]>p[1]):
+            x=finite(a[0]+finite(p[1]-a[1])*finite(b[0]-a[0])/finite(b[1]-a[1]))
+            if p[0]<x:inside=not inside
+    return 0. if inside else d
+
+
+def arc(p,c):
+    center=c['center'];radius=c['radius'];rho=finite(math.dist(p,center))
+    if c['kind']=='circle' or rho==0:return abs(rho-radius)
+    angle=math.atan2(p[1]-center[1],p[0]-center[0])
+    if on_sweep(angle,c['start_angle'],c['sweep_angle']):return abs(rho-radius)
+    return min(finite(math.dist(p,arc_point(center,radius,t)))for t in (c['start_angle'],c['start_angle']+c['sweep_angle']))
+
+
+def contour(p,c):
+    if c['kind']=='point':return finite(math.dist(p,c['point']))
+    if c['kind']in ('circle','arc'):return finite(arc(p,c))
+    if c['kind']=='polyline':
+        points=c['points']
+        if c.get('filled')or c.get('role')=='text_frame':return polygon(p,points)
+        pairs=list(zip(points,points[1:]))
+        if c.get('closed'):pairs.append((points[-1],points[0]))
+        if not pairs:raise ValueError('Empty contour')
+        return min(segment(p,a,b)for a,b in pairs)
+    raise ValueError('Unverified distance contour')
+
+
+def solid_circle(p,contours):
+    outer=contours[0];rho=finite(math.dist(p,outer['center']));radius=outer['radius']
+    if len(contours)==2 and contours[1].get('role')=='hole':
+        inner=contours[1]['radius']
+        return inner-rho if rho<inner else rho-radius if rho>radius else 0.
+    if outer['kind']=='circle':return max(0.,rho-radius)
+    if len(contours)!=2 or contours[1].get('role')!='chord':raise ValueError('Unverified circular fill boundary')
+    a,b=contours[1]['points'];middle=arc_point(outer['center'],radius,outer['start_angle']+outer['sweep_angle']/2)
+    side=finite(cross(a,b,middle));query_side=finite(cross(a,b,p))
+    if side==0:raise ValueError('Circular segment side is numerically indeterminate')
+    if rho<=radius and (query_side==0 or (side>0)==(query_side>0)):return 0.
+    return min(arc(p,outer),segment(p,a,b))
+
+
+def unknown(reason,*,upper=None,parts=None):
+    return dict(status='undetermined',value=None,lower_bound=0.,upper_bound=upper,reason=str(reason),
+                parts=[]if parts is None else parts,unknown_parts=True,distance_kind='shape_distance')
+
+
+def distance(g,p,text_mode='glyph'):
+    """A composite is a union. Known parts provide an upper bound only."""
+    parts=g.get('parts',[])
+    if parts:
+        values=[dict(distance(child,p,text_mode),child_path=child['child_path'],kind=child['kind'])for child in parts]
+        exact=[x['value']for x in values if x['status']=='exact']
+        unresolved=any(x['status']!='exact' or x['unknown_parts']for x in values)
+        bounds=[x['upper_bound']for x in values if x['upper_bound']is not None]
+        upper=min(bounds)if bounds else None
+        if unresolved and upper!=0:return unknown('A child distance is undetermined; known parts give only an upper bound',upper=upper,parts=values)
+        if not exact and upper!=0:return unknown('No exact child distance',parts=values)
+        value=0. if upper==0 else min(exact)
+        return dict(status='exact',value=value,lower_bound=value,upper_bound=value,reason=None,parts=values,
+                    unknown_parts=unresolved,distance_kind='composite_shape_and_text_frame_distance'if text_mode=='frame'else 'composite_shape_distance')
+    try:
+        field=g['contours']
+        if field['status']!='exact':
+            result=unknown(field.get('reason','No exact contour'))
+            if g['kind']=='text'and text_mode=='frame':result['distance_kind']='text_frame_distance'
+            return result
+        contours=field['value']
+        if not contours:raise ValueError('No distance contour')
+        value=solid_circle(p,contours)if g['kind']=='circle_solid'else min(contour(p,c)for c in contours)
+        value=finite(value)
+        if value<0:raise ValueError('Negative geometric distance')
+        kind='text_frame_distance'if g['kind']=='text'and text_mode=='frame'else 'shape_distance'
+        return dict(status='exact',value=value,lower_bound=value,upper_bound=value,reason=None,parts=[],unknown_parts=False,distance_kind=kind)
+    except (ValueError,KeyError,TypeError,OverflowError)as exc:return unknown(exc)

jwwkit/_spatial_query.py

@@ -0,0 +1,34 @@
+"""Use the existing JSON query engine on a detached snapshot, without file I/O."""
+from types import SimpleNamespace
+from jwwkit.read_view import _unpack
+from jwwkit.model.common_entities import model_entity
+from jwwkit.model.query import search
+
+
+class FrozenDocument:
+    def __init__(self,view,context):
+        self.header=context.header;self.includes_metadata=view.includes_metadata
+        self._source_bytes=None;self._header=view._source_header_bytes
+        blobs=view._records if context.o['basis']=='current'else view._persisted
+        self.missing=[i for i,b in enumerate(blobs)if b is None]
+        self.entities=tuple(model_entity(_unpack(b if b is not None else view._records[i]),source_index=view._indices[i])for i,b in enumerate(blobs))
+        self.block_definitions=tuple(SimpleNamespace(number=r['number'],name=r['name'],entities=())for r in context.definitions.values())
+        self.presets=context.presets
+
+    def get_group_scale(self,group):return self.header['layer_groups'][group]['scale']
+
+    def get_text_preset(self,number):
+        if self.presets['status']!='exact':raise ValueError('Frozen text presets are undetermined')
+        return dict(self.presets['values'][number-1])
+
+
+def select(view,context,query,remaining_seconds):
+    if query is None:return range(view.entity_count),[],None
+    doc=FrozenDocument(view,context);missing=set(doc.missing)
+    result=search(doc,query,scope='drawing',limits={'total_seconds':min(30.,remaining_seconds),'regex_seconds':min(5.,remaining_seconds)},
+                  _indices=[i for i in range(view.entity_count)if i not in missing])
+    unresolved=[dict(index=r['index'],reason=r['reason'])for r in result['unresolved']]
+    unresolved.extend(dict(index=i,reason='No persisted record to evaluate query')for i in doc.missing)
+    info={k:result[k]for k in ('input_query','effective_query','examined_count','resolutions','rules')}
+    info.update(source_sha256=view.source_sha256,model_sha256=view.model_sha256,basis=context.o['basis'],complete=not unresolved)
+    return [x['index']for x in result['hits']],unresolved,info