jwwkit 0.2.0__py3-none-any.whl

jwwkit/_commands/recognize_planar_tategu.py

@@ -0,0 +1,20 @@
+"""Read-only planar candidates. No answer/reference input is accepted."""
+import json
+from pathlib import Path
+from jwwkit.tategu_recognition import recognize_planar_tategu
+
+def add_arguments(parser):
+    parser.add_argument('--source',required=True,type=Path)
+    parser.add_argument('--tolerances',required=True,type=Path)
+    parser.add_argument('--output',required=True,type=Path)
+
+
+def run(args):
+    if args.output.exists():raise FileExistsError(args.output)
+    if args.output.resolve() in (args.source.resolve(),args.tolerances.resolve()):
+        raise ValueError('Output conflicts with input')
+    result=recognize_planar_tategu(args.source,tolerances=json.loads(args.tolerances.read_text(encoding='utf-8')))
+    with args.output.open('x',encoding='utf-8')as stream:
+        json.dump(result,stream,ensure_ascii=False,allow_nan=False,indent=2)
+    print(json.dumps({'candidates':len(result['recognized_candidates']),'complete':result['complete']}))
+    return 0 if result['complete']else 2

jwwkit/_commands/summarize_drawing.py

@@ -0,0 +1,16 @@
+"""Write a JWW JSON summary without modifying the input or overwriting output."""
+from pathlib import Path
+
+from jwwkit import CadDocument
+
+
+def add_arguments(parser):
+    parser.add_argument("--source", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+
+
+def run(args):
+    if args.output.exists():
+        raise FileExistsError(args.output)
+    result = CadDocument.open(args.source).write_summary(args.output)
+    print(f"entities={result['entity_count']}, definitions={len(result['block_definitions'])}, output={args.output}")

jwwkit/_comparison_composites.py

@@ -0,0 +1,179 @@
+"""Internal read-only compound comparison. No writer/transform permissions added."""
+import copy
+import math
+from collections import defaultdict,Counter
+
+
+def enrich(doc,row,scale,transform,point,children,stack):
+    from jwwkit.drawing_comparison import _finite,_json
+    g=row['geometry_paper_mm'];kind=row['type'];base=row['attributes'];angle=transform[0]
+    if kind=='DIMENSION':
+        if g['sxf_mode']!=0:raise ValueError('Dimension mode other than observed mode0 is not semantically verified')
+        records=[g['line'],g['text'],*g['aux_lines'],*g['aux_points']]
+        paths=['line','text',*[f'aux_lines[{i}]' for i in range(len(g['aux_lines']))],*[f'aux_points[{i}]' for i in range(len(g['aux_points']))]]
+        row['children']=children(records,scale)
+        for path,child in zip(paths,row['children']):child['child_path']=path
+        row['active_child_paths']=['line','text']
+        if any(c['status']!='supported' for c in row['children']):raise ValueError('Unsupported dimension child: '+str([(c['child_path'],c.get('reason')) for c in row['children'] if c['status']!='supported']))
+        anchor=row['children'][0]['anchor']
+        return [anchor],[],[],anchor,dict(sxf_mode=g['sxf_mode']),None
+    if kind=='BLOCK':
+        style=base['pen_style']
+        if style not in (0,1,2,3,64,65,66,67) or base['pen_width']!=0 or base['flag']!=0:
+            raise ValueError('Unverified block reference layer-priority attributes')
+        number=g['def_number']
+        if number in stack:raise ValueError('Cyclic block definition dependency')
+        if len(stack)>=64:raise ValueError('Block dependency depth exceeds 64')
+        definitions=[d for d in doc._source_records['block_defs'] if d['number']==number]
+        if len(definitions)!=1:raise ValueError('Missing or duplicate block definition number')
+        definition=definitions[0]
+        # Definition coordinates are paper-mm local coordinates, independent
+        # of each child's saved layer-group scale. Structure is not flattened.
+        row['children']=children(definition['entities'],1.,(0.,0.,0.),(*stack,number))
+        for i,child in enumerate(row['children']):child['child_path']=f'definition.entities[{i}]'
+        if any(c['status']!='supported' for c in row['children']):raise ValueError('Unsupported definition child: '+str([(c['child_path'],c.get('reason')) for c in row['children'] if c['status']!='supported']))
+        row['definition_storage']=copy.deepcopy(definition)
+        row['definition_identity']=dict(number=number,name=definition['name'])
+        pos=point(g['ref_x'],g['ref_y']);rotation=(_finite(g['rotation'],'block rotation')+math.radians(angle))%(2*math.pi)
+        sx,sy=(_finite(g[k],k) for k in ('scale_x','scale_y'))
+        if sx==0 or sy==0:raise ValueError('Degenerate zero block scale')
+        attrs=dict(layer_priority=bool(style&64),saved_scale_x=sx,saved_scale_y=sy,
+                   definition=dict(name=definition['name'],base=copy.deepcopy(definition['base'])))
+        return [pos],[sx*scale,sy*scale],[(rotation,2*math.pi)],pos,attrs,None
+    if kind=='SOLID':
+        pts=[point(g[f'point{i}_x'],g[f'point{i}_y']) for i in (1,3,2,4)]
+        # Native perimeter slot order is 1,3,2,4. Keep the raw slots in JSON.
+        clean=[]
+        for p in pts:
+            if not clean or p!=clean[-1]:clean.append(p)
+        if len(clean)>1 and clean[0]==clean[-1]:clean.pop()
+        pts=min((seq[n:]+seq[:n] for seq in (clean,list(reversed(clean))) for n in range(len(clean))),key=_json)
+        anchor=[sum(p[i] for p in pts)/len(pts) for i in (0,1)]
+        return pts,[],[],anchor,dict(explicit_color=g['color']),None
+    if kind!='CIRCLE_SOLID':raise ValueError('Unknown compound type')
+    from jwwkit.model.circular_solid import validate_circular_solid
+    validate_circular_solid(row['raw_record'])
+    center=point(g['center_x'],g['center_y']);radius=_finite(g['radius'],'radius')*scale
+    flat=_finite(g['flatness'],'flatness');tilt=_finite(g['tilt_angle'],'tilt')+math.radians(angle)
+    a,b=max(radius,radius*flat),min(radius,radius*flat)
+    orientation=0. if a==b else (tilt+(math.pi/2 if flat>1 else 0))%math.pi
+    pts=[center];lengths=[a,b];angles=[(orientation,math.pi)]
+    attrs=dict(explicit_color=g['color'],fill_representation='ring' if base['pen_style']==105 else g['solid_mode'])
+    if base['pen_style']==105:lengths.append(g['solid_mode']*scale)
+    elif g['solid_mode']==5.:
+        start,sweep=g['start_angle'],g['arc_angle']
+        def on(t):
+            x,y=radius*math.cos(t),radius*flat*math.sin(t)
+            return [center[0]+math.cos(tilt)*x-math.sin(tilt)*y,center[1]+math.sin(tilt)*x+math.cos(tilt)*y]
+        pts+=sorted([on(start),on(start+sweep)])+[on(start+sweep/2)]
+        angles.append((abs(sweep),0))
+    return pts,lengths,angles,center,attrs,None
+
+
+def semantic_key(row):
+    """Canonical semantic multiset; never include archive numbers/dates/order."""
+    from jwwkit.drawing_comparison import _json
+    children=row.get('children',[])
+    if row['type']=='DIMENSION':
+        # mode0 auxiliary positions are unused, but their attributes matter.
+        nested=[[c['child_path'],semantic_key(c) if c['child_path'] in row['active_child_paths'] else [c['type'],c['comparison_attributes'],c['content']]] for c in children]
+    else:nested=sorted([semantic_key(c) for c in children],key=_json)
+    return [row['type'],row['comparison_geometry'],row['comparison_attributes'],row['content'],nested]
+
+
+def child_correspondence(a,b,pt,at):
+    from jwwkit.drawing_comparison import _geometry,_signature,_json
+    left,right=a.get('children',[]),b.get('children',[])
+    if len(left)!=len(right):return None
+    if a['type']=='DIMENSION':
+        pairs=[]
+        for i,(x,y) in enumerate(zip(left,right)):
+            if x['child_path']!=y['child_path']:return None
+            err=_geometry(x,y,pt,at) if x['child_path'] in a['active_child_paths'] else dict(unused_mode0_geometry=True)
+            if err is None:return None
+            pairs.append(dict(left=i,right=i,errors=err))
+        return dict(child_pairs=pairs,nested_ambiguous=any(p['errors'].get('nested_ambiguous',False) for p in pairs))
+    la=set(range(len(left)));rb=set(range(len(right)));pairs=[]
+    # Exact children first, including duplicates as a multiset, then geometric
+    # candidates. This prevents order/number changes from inventing differences.
+    ga,gb=defaultdict(list),defaultdict(list)
+    for i,r in enumerate(left):ga[_signature(r)].append(i)
+    for j,r in enumerate(right):gb[_signature(r)].append(j)
+    for key in sorted(ga.keys()&gb.keys()):
+        for i,j in zip(ga[key],gb[key]):pairs.append(dict(left=i,right=j,errors=_geometry(left[i],right[j],pt,at)));la.remove(i);rb.remove(j)
+    if not la:return dict(child_pairs=pairs,nested_ambiguous=False)
+    edges={}
+    if len(la)*len(rb)>200000:raise ValueError('Definition child candidate limit exceeded')
+    for i in sorted(la):
+        for j in sorted(rb):
+            err=_geometry(left[i],right[j],pt,at)
+            if err is not None:edges[i,j]=err
+    ca=Counter(i for i,j in edges);cb=Counter(j for i,j in edges)
+    if any(i not in ca for i in la) or any(j not in cb for j in rb):return None
+    ambiguous=any(ca[i]!=1 for i in la) or any(cb[j]!=1 for j in rb)
+    if ambiguous:return dict(child_pairs=pairs,nested_ambiguous=True)
+    for (i,j),err in sorted(edges.items()):pairs.append(dict(left=i,right=j,errors=err))
+    return dict(child_pairs=pairs,nested_ambiguous=any(p['errors'].get('nested_ambiguous',False) for p in pairs))
+
+
+def changes(a,b,errors,size_tolerance,path=''):
+    """Compound members remain children of one counted root. Keep child paths."""
+    from jwwkit.drawing_comparison import _differences,_geometry
+    attrs=_differences(a['comparison_attributes'],b['comparison_attributes'],path,size_tolerance)
+    contents=[];storage=[]
+    if a['content']!=b['content']:contents.append(dict(field=path+'.content',before=a['content'],after=b['content']))
+    if a['type']=='BLOCK':
+        storage=_differences(a['definition_storage'],b['definition_storage'],path+'.definition_storage')
+    for p in (errors or {}).get('child_pairs',[]):
+        i,j=p['left'],p['right'];x,y=a['children'][i],b['children'][j]
+        child_path=path+'.'+x['child_path']
+        ac,cc,sc=changes(x,y,p['errors'],size_tolerance,child_path)
+        attrs+=ac;contents+=cc;storage+=sc
+    return attrs,contents,storage
+
+
+def definitions_report(left,right,pt,at,st):
+    """Selected transitive definitions, independently of archive reference IDs."""
+    from jwwkit.drawing_comparison import _json,_differences
+    def collect(rows):
+        found={}
+        def visit(r):
+            if r['status']!='supported':return
+            if r['type']=='BLOCK':found.setdefault(r['definition_identity']['number'],r)
+            for c in r.get('children',[]):visit(c)
+        for r in rows:visit(r)
+        return found
+    aa,bb=collect(left),collect(right);la=set(aa);rb=set(bb);pairs=[];ambiguous=[]
+    def key(r):return _json([r['comparison_attributes']['definition'],sorted([semantic_key(c) for c in r['children']],key=_json)])
+    ga,gb=defaultdict(list),defaultdict(list)
+    for n,r in aa.items():ga[key(r)].append(n)
+    for n,r in bb.items():gb[key(r)].append(n)
+    for k in sorted(ga.keys()&gb.keys()):
+        for i,j in zip(sorted(ga[k]),sorted(gb[k])):pairs.append((i,j));la.remove(i);rb.remove(j)
+    # A unique saved name allows reporting a changed definition; it never
+    # makes changed geometry equal. Duplicate names remain explicit holds.
+    names_a,names_b=defaultdict(list),defaultdict(list)
+    for i in sorted(la):names_a[aa[i]['definition_identity']['name']].append(i)
+    for j in sorted(rb):names_b[bb[j]['definition_identity']['name']].append(j)
+    for name in sorted(names_a.keys()&names_b.keys()):
+        ids,jds=names_a[name],names_b[name]
+        if len(ids)==len(jds)==1:pairs.append((ids[0],jds[0]))
+        else:ambiguous.append(dict(name=name,left_numbers=ids,right_numbers=jds))
+        la.difference_update(ids);rb.difference_update(jds)
+    rows=[]
+    for i,j in sorted(pairs):
+        a,b=aa[i],bb[j];err=child_correspondence(a,b,pt,at)
+        is_ambiguous=bool(err and err.get('nested_ambiguous'))
+        if is_ambiguous:ambiguous.append(dict(left_numbers=[i],right_numbers=[j],reason='non_unique_definition_children'))
+        attrs=_differences(a['comparison_attributes']['definition'],b['comparison_attributes']['definition'],'.definition',st)
+        contents=[]
+        if err and not is_ambiguous:
+            for p in err['child_pairs']:
+                ac,cc,_=changes(a['children'][p['left']],b['children'][p['right']],p['errors'],st,'.definition.entities['+str(p['left'])+']')
+                attrs+=ac;contents+=cc
+        rows.append(dict(left_number=i,right_number=j,number_changed=i!=j,name_before=a['definition_identity']['name'],name_after=b['definition_identity']['name'],
+                         geometry_equal=err is not None and not is_ambiguous,attribute_changes=attrs,content_changes=contents,
+                         semantic_equal=err is not None and not is_ambiguous and not attrs and not contents,
+                         storage_differences=_differences(a['definition_storage'],b['definition_storage']),
+                         before=a['definition_storage'],after=b['definition_storage']))
+    return dict(matches=rows,left_only=sorted(la),right_only=sorted(rb),ambiguous=ambiguous)

jwwkit/_edit_result_core.py

@@ -0,0 +1,175 @@
+"""Private atomic adapter for the 31 approved CadDocument methods only."""
+import copy,hashlib,inspect,json
+from dataclasses import is_dataclass,asdict
+from types import SimpleNamespace
+from pathlib import Path
+from jwwkit.cad_model import CadDocument
+from jwwkit.model.common_entities import CadEntity,CadBlockDefinition
+
+NAMES=('delete_entity','delete_entities','move_entities','move_entity','transform_entities','copy_entities',
+ 'align_two_points','rotate_entities','reflect_entities','scale_entities','set_entity_attributes','set_text',
+ 'recalculate_text_endpoint','set_group_scale','add_line','add_text','add_circle','add_point','add_solid',
+ 'add_circle_solid','set_group_state','set_layer_state','set_layer_name','set_group_name','add_block_definition',
+ 'add_arc','set_dimension_text','place_block','replace_entities_with_block','set_block_layer_priority','import_group')
+METHODS={name:getattr(CadDocument,name)for name in NAMES}
+ADDITIONS={'add_line','add_text','add_circle','add_arc','add_point','add_solid','add_circle_solid','place_block'}
+RESOURCES={'set_group_scale':'group','set_group_name':'group','set_group_state':'group',
+ 'set_layer_name':'layer','set_layer_state':'layer','add_block_definition':'definition'}
+
+def canonical(v):return json.dumps(v,ensure_ascii=True,sort_keys=True,separators=(',',':'),allow_nan=False)
+def digest(v):return hashlib.sha256(canonical(v).encode('ascii')).hexdigest()
+def detached(v):return json.loads(canonical(v))
+def equal(a,b):return canonical(a)==canonical(b)
+
+def copying(name,parameters):
+    return name=='copy_entities'or name=='transform_entities'and parameters.get('options',{}).get('copy_entities',False)or name in ('rotate_entities','reflect_entities','scale_entities')and parameters.get('options',{}).get('copy',False)
+
+def options(limit,mode):
+    if type(limit)is not int or not 0<=limit<=1000 or mode not in ('details','summary','count'):
+        raise ValueError('limit must be integer 0..1000; mode details/summary/count')
+
+def capture(cad):
+    from jwwkit.safe_edit import snapshot
+    from jwwkit.model.group_import import definition_records
+    s=snapshot(cad)
+    state=dict(entities=s['entities'],groups=s['groups'],definitions=list(definition_records(cad).values()),
+               metadata=cad.metadata_settings,version=cad.version,origin_sha256=hashlib.sha256(cad._source_bytes).hexdigest())
+    return detached(state)
+
+def _rows(before,after,pairs):
+    changes=[];paired_old=set();paired_new=set();counts=dict(added=0,modified=0,deleted=0,rejected=0,unchanged=0)
+    for i,j in pairs:
+        paired_old.add(i);paired_new.add(j)
+        if equal(before['entities'][i],after['entities'][j]):counts['unchanged']+=1
+        else:
+            counts['modified']+=1;changes.append(dict(resource_type='entity',change='modified',before_index=i,after_index=j,before=before['entities'][i],after=after['entities'][j]))
+    for i,e in enumerate(before['entities']):
+        if i not in paired_old:counts['deleted']+=1;changes.append(dict(resource_type='entity',change='deleted',before_index=i,after_index=None,before=e,after=None))
+    for j,e in enumerate(after['entities']):
+        if j not in paired_new:counts['added']+=1;changes.append(dict(resource_type='entity',change='added',before_index=None,after_index=j,before=None,after=e))
+    resources=dict(definitions=0,groups=0,layers=0)
+    old={x['number']:x for x in before['definitions']};new={x['number']:x for x in after['definitions']}
+    for number in sorted(old.keys()|new.keys()):
+        a=old.get(number);b=new.get(number)
+        if not equal(a,b):resources['definitions']+=1;changes.append(dict(resource_type='definition',number=number,change='added'if a is None else 'deleted'if b is None else 'modified',before=a,after=b))
+    for g,(a,b)in enumerate(zip(before['groups'],after['groups'])):
+        ga={k:a[k]for k in ('name','scale','state')};gb={k:b[k]for k in ga}
+        if not equal(ga,gb):resources['groups']+=1;changes.append(dict(resource_type='group',layer_group=g,change='modified',before=ga,after=gb))
+        for l in range(16):
+            la=dict(name=a['layers'][l],state=a['layer_states'][l]);lb=dict(name=b['layers'][l],state=b['layer_states'][l])
+            if not equal(la,lb):resources['layers']+=1;changes.append(dict(resource_type='layer',layer_group=g,layer=l,change='modified',before=la,after=lb))
+    return counts,resources,changes
+
+def net_rows(before,after):
+    old=[x['source_index']for x in before['entities']]
+    if None in old or len(set(old))!=len(old):raise RuntimeError('Net plan result needs fresh unique source indices')
+    current={x['source_index']:j for j,x in enumerate(after['entities'])if x['source_index']is not None}
+    if len(current)!=sum(x['source_index']is not None for x in after['entities'])or not current.keys()<=set(old):raise RuntimeError('Invalid original lineage after execution')
+    return _rows(before,after,[(i,current[k])for i,k in enumerate(old)if k in current])
+
+def result(operation,status,phase,before=None,after=None):
+    return dict(schema_version=1,operation=operation,status=status,phase=phase,
+        counts=dict(added=0,modified=0,deleted=0,rejected=0,unchanged=len(before['entities'])if before else 0),
+        resource_counts=dict(definitions=0,groups=0,layers=0),changes=[],rejections=[],resource_rejections=[],warnings=[],warning_count=0,
+        rejected_operation_count=0,rejected_addition_count=0,before_model_sha256=digest(before)if before else None,
+        after_model_sha256=digest(after or before)if before else None,approval_plan_sha256=None,
+        detail_page=dict(total=0,returned=0,truncated=False,has_more=False,continuation_supported=False),operation_data=None)
+
+def bounded(items,limit,mode):
+    output=[];size=0
+    if mode=='details':
+        for row in items[:limit]:
+            amount=len(canonical(row).encode('ascii'))
+            if size+amount>1048576:break
+            output.append(detached(row));size+=amount
+    return output,dict(total=len(items),returned=len(output),truncated=len(output)<len(items),has_more=len(output)<len(items),continuation_supported=False,max_bytes=1048576)
+
+def present(value,limit=100,mode='details'):
+    options(limit,mode);v=copy.deepcopy(value);v['changes'],v['detail_page']=bounded(v['changes'],limit,mode)
+    v['error_summary']=None
+    if v['rejections']:
+        first=v['rejections'][0];message=first.get('message','')
+        v['error_summary']=dict(code=first.get('code'),exception_type=first.get('exception_type'),message=message[:4096],message_truncated=len(message)>4096)
+    v['warning_codes']=sorted({x['code']for x in v['warnings']})
+    for key in ('warnings','rejections','resource_rejections'):
+        rows=v[key];v[key],page=bounded(rows,limit,mode);v[key+'_details']=page
+    if mode!='details':v['operation_data']=None
+    return v
+
+def data(value):
+    from jwwkit.safe_edit import entity_view
+    if isinstance(value,CadEntity):return dict(entity_view(value),source_index=value.source_index)
+    if isinstance(value,CadBlockDefinition):return dict(number=value.number,name=value.name,attributes=dict(value.attributes),entities=[data(e)for e in value.entities])
+    from jwwkit.model.block_operations import RecordChild
+    if isinstance(value,RecordChild):return dict(record=data(value.value))
+    if is_dataclass(value):return dict(model_type=type(value).__name__,values=data(asdict(value)))
+    if isinstance(value,Path):return str(value)
+    if isinstance(value,(list,tuple)):return [data(x)for x in value]
+    if isinstance(value,dict):return {str(k):data(v)for k,v in value.items()}
+    if value is None or type(value)in (str,int,float,bool):return value
+    raise TypeError('Unrepresentable operation return type: '+type(value).__name__)
+
+class Rejected(Exception):
+    def __init__(self,record):self.record=record;super().__init__(record['rejections'][0]['message'])
+
+class Failed(Exception):
+    def __init__(self,record):self.record=record;super().__init__(record['rejections'][0]['message'])
+
+def refusal(name,before,bound,exc,code='EDIT_REFUSED'):
+    r=result(name,'rejected','memory',before);r['rejected_operation_count']=1
+    args=bound.arguments if bound else {};targets=[args['index']]if 'index'in args else args.get('indices')
+    valid=isinstance(targets,(list,tuple))and all(type(i)is int and 0<=i<len(before['entities'])for i in targets)and len(set(targets))==len(targets)
+    r['counts']['rejected']=len(targets)if valid else 0 if name in ADDITIONS or name in RESOURCES else None
+    r['rejected_addition_count']=1 if name in ADDITIONS else len(targets)if copying(name,args)and valid else None if name=='import_group'else 0
+    if name in RESOURCES:
+        try:request={k:data(v)for k,v in args.items()if k!='self'}
+        except TypeError:request=dict(unrepresentable_input=True)
+        r['resource_rejections']=[dict(resource_type=RESOURCES[name],request=request)]
+    r['rejections']=[dict(code=code,exception_type=type(exc).__name__,message=str(exc),targets=targets if valid else None)]
+    return r
+
+def apply_method(cad,name,/,*args,**kwargs):
+    """Private: called only inside the approved plan engine or its dry run."""
+    before=capture(cad);bound=None
+    if type(cad)is not CadDocument or name not in METHODS:raise Rejected(refusal(name,before,None,ValueError('PLAN_OPERATION_UNSUPPORTED'),'PLAN_OPERATION_UNSUPPORTED'))
+    staged=copy.deepcopy(cad);args=copy.deepcopy(args);kwargs=copy.deepcopy(kwargs)
+    try:
+        try:
+            bound=inspect.signature(METHODS[name]).bind(staged,*args,**kwargs)
+            bound=SimpleNamespace(arguments=copy.deepcopy({k:v for k,v in bound.arguments.items()if k!='self'}))
+        except TypeError as exc:raise Rejected(refusal(name,before,None,exc,'INVALID_ARGUMENTS'))from exc
+        try:
+            returned=METHODS[name](staged,*args,**kwargs)
+            if name=='align_two_points'and not returned['passed']:raise ValueError('; '.join(returned['reasons']))
+        except (ValueError,TypeError,IndexError)as exc:raise Rejected(refusal(name,before,bound,exc))from exc
+        try:
+            from jwwkit.writer.preserved import _document_bytes
+            _document_bytes(staged)
+        except (ValueError,TypeError,IndexError)as exc:raise Rejected(refusal(name,before,bound,exc,'SAVE_PREFLIGHT_REFUSED'))from exc
+        after=capture(staged);n=len(cad.entities);m=len(staged.entities);deleted=set()
+        if name=='delete_entity':deleted={bound.arguments['index']}
+        elif name in ('delete_entities','replace_entities_with_block'):
+            deleted=set(bound.arguments['indices'])
+            if name=='replace_entities_with_block':deleted.remove(min(deleted))
+        pairs=[(i,j)for j,i in enumerate(i for i in range(n)if i not in deleted)]
+        expected=n+1 if name in ADDITIONS else n+len(bound.arguments['indices'])if copying(name,bound.arguments) else n+returned['added_count']if name=='import_group'else n-len(deleted)
+        if m!=expected:raise RuntimeError('Unexpected root population after method')
+        counts,resources,changes=_rows(before,after,pairs)
+        r=result(name,'applied'if changes else 'unchanged','memory',before,after)
+        r.update(counts=counts,resource_counts=resources,changes=changes,operation_data=data(returned))
+        if name=='set_group_scale'and resources['groups']:r['warnings'].append(dict(code='GROUP_SCALE_PAPER_FIXED',message='Paper coordinates remain fixed; real coordinates change with group scale.'))
+        if name=='import_group'and bound.arguments.get('settings_policy')=='destination':r['warnings'].append(dict(code='DESTINATION_RENDERING_SETTINGS',message='Imported attribute codes retain their values; appearance follows destination settings.'))
+        if name=='replace_entities_with_block'and any(before['entities'][i]['record']['attributes']['flag']&2 for i in bound.arguments['indices']):r['warnings'].append(dict(code='BLOCK_FLAG2_NORMALIZATION',message='Only observed definition-child flag2 normalization follows Jw_cad control.'))
+        r['warning_count']=len(r['warnings'])
+        # Preserve identities of surviving unchanged roots for existing aliases.
+        roots=list(staged.entities)
+        for i,j in pairs:
+            if equal(before['entities'][i],after['entities'][j]):roots[j]=cad.entities[i]
+        staged.entities=tuple(roots)
+        completed=(r,returned)
+        cad.__dict__=staged.__dict__
+        return completed
+    except Rejected:raise
+    except Exception as exc:
+        r=result(name,'failed','memory',before);r['rejections']=[dict(code='EDIT_EXECUTION_FAILED',exception_type=type(exc).__name__,message=str(exc))]
+        raise Failed(r)from exc

jwwkit/_ezjww_adapter.py

@@ -0,0 +1,12 @@
+"""Internal boundary for the required ezjww 0.2.13 reader.
+
+This is a transparent adapter, not a new parser or validation policy.
+See docs/ezjww_adapter_contract.md for the consumed result contract.
+Keep the import eager: making the dependency optional belongs to a later design.
+"""
+import ezjww as _ezjww
+
+
+def read_native_document(path):
+    """Delegate once; preserve the native result object and exception unchanged."""
+    return _ezjww.read_document(str(path))

jwwkit/_geometry_engine.py

@@ -0,0 +1,204 @@
+"""Bounded logical geometry of qualified JWW storage, not rendered font/stroke ink."""
+import math
+from jwwkit._geometry_math import (TAU,point,compose,block_matrix,bounds,union,arc_point,arc_bounds,polygon)
+from jwwkit.model.text_metrics import text_endpoint
+from jwwkit.model.circular_solid import validate_circular_solid
+
+FIELDS=('bbox','segments','contours','center','representative_points','text_frame','glyph_bbox')
+
+
+def item(status,value=None,reason=None,method=None):
+    return dict(status=status,value=value,reason=reason,method=method)
+
+
+def exact(value,method):return item('exact',value,method=method)
+def unknown(reason):return item('undetermined',reason=str(reason))
+def na(reason='No unique applicable quantity'):return item('not_applicable',reason=reason)
+
+
+def blank():return {k:item('not_requested') for k in FIELDS}
+
+
+class GeometryLimit(ValueError):pass
+
+
+class Engine:
+    def __init__(self,definitions,presets,fields,text_mode,tolerance,limits,*,real_per_unit=None):
+        self.definitions=definitions;self.presets=presets;self.fields=fields;self.text_mode=text_mode
+        self.tolerance=tolerance;self.limits=limits;self.nodes=0;self.segment_count=0
+        self.real_per_unit=real_per_unit
+
+    def segments(self,segments,approximate=False):
+        self.segment_count+=len(segments)
+        if self.segment_count>self.limits['max_segments']:return unknown('Segment limit exceeded; no silently truncated geometry')
+        return item('approximate' if approximate else 'exact',segments,method='bounded_sagitta' if approximate else 'stored_line_segments')
+
+    def curve_segments(self,center,radius,start,sweep,closed=False):
+        if self.tolerance is None:return unknown('Explicit curve_tolerance is required for curve line approximation')
+        step=min(math.pi,4*math.asin(math.sqrt(min(1.,self.tolerance/(2*radius)))))
+        if step<=0:return unknown('Requested curve tolerance is below representable resolution')
+        n=max(4 if closed else 1,math.ceil(abs(sweep)/step))
+        if n+self.segment_count>self.limits['max_segments']:return unknown('Segment limit exceeded; analytic contour and bbox remain available')
+        pts=[arc_point(center,radius,start+sweep*i/n) for i in range(n+1)]
+        if closed:pts[-1]=pts[0]
+        result=self.segments([dict(start=a,end=b)for a,b in zip(pts,pts[1:])],True)
+        result['max_deviation']=2*radius*math.sin(abs(sweep)/(4*n))**2
+        result['requested_max_deviation']=self.tolerance
+        return result
+
+    def text_frame(self,r,matrix,similarity):
+        try:
+            if not similarity:raise ValueError('Nonuniform block text-frame rendering is unverified')
+            base=r['base']
+            if base['flag']!=0 or base['pen_width']!=0:raise ValueError('Special/flagged/dimension text frame is unverified')
+            if type(r['text_type'])is not int or not 0<=r['text_type']<=10:raise ValueError('Unverified text preset')
+            sizes={k:r[k]for k in ('size_x','size_y','spacing')}
+            if r['text_type']:
+                if self.presets.get('status')!='exact':raise ValueError('Text preset table unverified')
+                preset=self.presets['values'][r['text_type']-1]
+                # Ordinary frames require stored and declared sizes to agree;
+                # do not silently resolve contradictory source representations.
+                if any(r[k]!=preset[k]for k in sizes):raise ValueError('Stored/preset text sizes disagree')
+            expected=text_endpoint((r['start_x'],r['start_y']),r['content'],**sizes,
+                                   angle=r['angle'],font_name=r['font_name'],alignment=base['pen_style'])
+            saved=(r['end_x'],r['end_y'])
+            # Numerical verification only, not an application/drawing tolerance.
+            magnitude=max(1.,abs(r['start_x']),abs(r['start_y']),*map(abs,saved),*map(abs,expected))
+            length=math.dist((r['start_x'],r['start_y']),expected)
+            numeric_guard=max(64*math.ulp(magnitude),1e-9*length)
+            real_scale=math.hypot(matrix[0],matrix[2])*self.real_per_unit if self.real_per_unit is not None else None
+            if real_scale is None or not math.isfinite(real_scale)or real_scale<=0:
+                raise ValueError('Real-coordinate conversion for text roundoff guard is unverified')
+            real_guard=numeric_guard*real_scale
+            if not math.isfinite(real_guard)or real_guard>=1e-4:
+                raise ValueError('Text roundoff guard reaches the real-mm safety cap')
+            if math.dist(saved,expected)>numeric_guard:raise ValueError('Saved endpoint does not match the verified ordinary-text rule')
+            angle=math.radians(r['angle']);h=r['size_y'];nx,ny=-h*math.sin(angle),h*math.cos(angle)
+            corners=[point(matrix,r['start_x'],r['start_y']),point(matrix,*saved),
+                     point(matrix,saved[0]+nx,saved[1]+ny),point(matrix,r['start_x']+nx,r['start_y']+ny)]
+            return exact(dict(kind='text_frame',corners=corners,bbox=bounds(corners),
+                              is_glyph_outline=False,baseline=[corners[0],corners[1]],
+                              endpoint_residual_paper_mm=math.dist(saved,expected),numeric_guard_paper_mm=numeric_guard,
+                              numeric_guard_real_mm=real_guard,numeric_guard_rule='ordinary-endpoint-roundoff-2'),
+                         'saved_start_end_height_angle_with_verified_ordinary_endpoint')
+        except (ValueError,KeyError,TypeError,OverflowError)as exc:return unknown(exc)
+
+    def build(self,r,matrix,similarity=True,stack=(),depth=0,path=()):
+        self.nodes+=1
+        if self.nodes>self.limits['max_children']or depth>self.limits['max_depth']:raise GeometryLimit('Geometry expansion/depth limit exceeded')
+        out=blank();out.update(kind=r['type'].lower(),child_path=list(path),parts=[],partial_bbox=None)
+        for field in ('text_frame','glyph_bbox'):out[field]=na()
+        try:
+            kind=r['type']
+            if kind in ('BLOCK','DIMENSION'):
+                out['center']=na('Composite has no unique geometric center');out['text_frame']=na('Inspect text parts for their individual frames')
+                parts=[]
+                if kind=='BLOCK':
+                    base=r['base']
+                    if base['pen_style']not in (0,1,2,3,64,65,66,67)or base['flag']!=0 or base['pen_width']!=0:raise ValueError('Unverified block reference attributes')
+                    number=r['def_number']
+                    if number in stack:raise ValueError('Cyclic block definition')
+                    if number not in self.definitions:raise ValueError('Missing block definition')
+                    local,uniform=block_matrix(r);child_matrix=compose(matrix,local)
+                    parts=[self.build(child,child_matrix,similarity and uniform,stack+(number,),depth+1,path+('definition',i)) for i,child in enumerate(self.definitions[number]['entities'])]
+                    anchor=point(matrix,r['ref_x'],r['ref_y'])
+                    out['representative_points']=exact([dict(point=anchor,point_kind='block_insertion',on_geometry=None)],'stored_block_anchor')
+                else:
+                    if r['sxf_mode']!=0:raise ValueError('Only verified mode0 dimension geometry is supported')
+                    # mode0 auxiliaries retain their storage but are not drawn.
+                    parts=[self.build(r[key],matrix,similarity,stack,depth+1,path+(key,)) for key in ('line','text')]
+                    out['ignored_storage_parts']=['aux_lines','aux_points']
+                    out['representative_points']=exact([dict(point=point(matrix,r['line']['start_x'],r['line']['start_y']),point_kind='dimension_line_start',on_geometry=True)],'active_dimension_line')
+                out['parts']=parts
+                if not parts:raise ValueError('Empty composite has no geometry')
+                boxes=[p['bbox']['value']for p in parts if p['bbox']['status']=='exact']
+                out['partial_bbox']=union(boxes)if boxes else None
+                out['bbox']=exact(union(boxes),'complete_child_union')if len(boxes)==len(parts)else unknown('A child bbox is undetermined; partial_bbox is not the whole extent')
+                for field in ('contours','segments'):
+                    statuses=[p[field]['status']for p in parts]
+                    if all(s in ('exact','approximate','not_applicable')for s in statuses):
+                        values=[x for p in parts for x in (p[field]['value']or [])]
+                        out[field]=item('approximate'if 'approximate'in statuses else 'exact',values,method='complete_child_union')
+                    else:out[field]=unknown('A child '+field+' is undetermined')
+                return out
+            if kind=='LINE':
+                a,b=(point(matrix,r[p+'_x'],r[p+'_y'])for p in ('start','end'))
+                out['bbox']=exact(bounds([a,b]),'segment_endpoints')
+                out['center']=exact(dict(point=[a[i]/2+b[i]/2 for i in (0,1)],center_kind='segment_midpoint'),'segment_midpoint')
+                out['segments']=self.segments([dict(start=a,end=b)])
+                out['contours']=exact([dict(kind='polyline',points=[a,b],closed=False,role='open')],'stored_line')
+                out['representative_points']=exact([dict(point=p,point_kind=k,on_geometry=True)for p,k in ((a,'start'),(b,'end'),(out['center']['value']['point'],'midpoint'))],'segment_points')
+            elif kind=='POINT':
+                p=point(matrix,r['x'],r['y']);out['bbox']=exact(bounds([p]),'geometric_point_not_marker_glyph')
+                out['center']=exact(dict(point=p,center_kind='point'),'stored_point')
+                out['segments']=na('A point has no line segment');out['contours']=exact([dict(kind='point',point=p)],'stored_point')
+                out['representative_points']=exact([dict(point=p,point_kind='point',on_geometry=True)],'stored_point')
+                out['marker_glyph']=unknown('Point marker glyph/stroke extent is outside geometric-point scope')
+            elif kind=='TEXT':
+                frame=self.text_frame(r,matrix,similarity);out['text_frame']=frame
+                out['glyph_bbox']=unknown('Rendered font glyph outline is not inferred from stored text frame')
+                a,b=point(matrix,r['start_x'],r['start_y']),point(matrix,r['end_x'],r['end_y'])
+                out['representative_points']=exact([dict(point=p,point_kind=k,on_geometry=None)for p,k in ((a,'text_start'),(b,'text_end'))],'stored_text_anchors_not_glyph_points')
+                if self.text_mode=='frame'and frame['status']=='exact':
+                    pts=frame['value']['corners'];out['bbox']=exact(bounds(pts),'text_frame_not_glyph')
+                    out['contours']=exact([dict(kind='polyline',points=pts,closed=True,role='text_frame')],'logical_text_frame')
+                    out['segments']=self.segments([dict(start=a,end=b)for a,b in zip(pts,pts[1:]+pts[:1])])
+                    out['center']=exact(dict(point=[sum(p[i]/4 for p in pts)for i in (0,1)],center_kind='text_frame_center_not_glyph'),'logical_text_frame')
+                else:
+                    reason=frame['reason']if self.text_mode=='frame'else 'Glyph geometry is undetermined; choose text_mode=frame for the separate logical frame'
+                    for field in ('bbox','contours','segments','center'):out[field]=unknown(reason)
+            elif kind=='SOLID':
+                pts,centroid,orientation=polygon([point(matrix,r[f'point{i}_x'],r[f'point{i}_y'])for i in (1,3,2,4)])
+                out['bbox']=exact(bounds(pts),'qualified_perimeter_vertices')
+                out['contours']=exact([dict(kind='polyline',points=pts,closed=True,role='outer',orientation=orientation,filled=True)],'simple_solid_polygon')
+                out['segments']=self.segments([dict(start=a,end=b)for a,b in zip(pts,pts[1:]+pts[:1])])
+                out['center']=exact(dict(point=centroid,center_kind='area_centroid'),'signed_polygon_area')
+                out['representative_points']=exact([dict(point=p,point_kind='vertex',on_geometry=True)for p in pts],'polygon_vertices')
+            elif kind in ('CIRCLE','ARC','CIRCLE_SOLID'):
+                center=point(matrix,r['center_x'],r['center_y'])
+                out['center']=exact(dict(point=center,center_kind='supporting_circle_center'),'stored_center')
+                out['representative_points']=exact([dict(point=center,point_kind='circle_center',on_geometry=None if kind=='CIRCLE_SOLID'else False)],'stored_center')
+                if r['flatness']!=1 or not similarity:raise ValueError('Ellipse/nonuniform circular transform is undetermined; center alone is known')
+                if kind=='CIRCLE_SOLID':validate_circular_solid(r)
+                scale=math.hypot(matrix[0],matrix[2]);radius=r['radius']*scale
+                if not math.isfinite(radius)or radius<=0:raise ValueError('Positive finite radius required')
+                full=kind=='CIRCLE'or kind=='CIRCLE_SOLID'and (r['base']['pen_style']==105 or r['solid_mode']==100.)
+                sweep=TAU if full else r['arc_angle']
+                if not math.isfinite(sweep)or not 0<abs(sweep)<=TAU:raise ValueError('Unverified circular sweep')
+                angle=r['start_angle']+r['tilt_angle'];direction=point(matrix,r['center_x']+math.cos(angle),r['center_y']+math.sin(angle))
+                start=math.atan2(direction[1]-center[1],direction[0]-center[0])
+                if matrix[0]*matrix[3]-matrix[1]*matrix[2]<0:sweep=-sweep
+                if full:start=0.;sweep=TAU
+                contours=[dict(kind='circle'if full else 'arc',center=center,radius=radius,start_angle=start,sweep_angle=sweep,closed=full,role='outer'if kind=='CIRCLE_SOLID'else 'curve')]
+                out['bbox']=exact(arc_bounds(center,radius,start,sweep),'analytic_circle_or_arc_extrema')
+                center_in_shape=kind=='CIRCLE_SOLID'and r['base']['pen_style']!=105 and (full or abs(sweep)>=math.pi)
+                out['representative_points']=exact([dict(point=center,point_kind='circle_center',on_geometry=center_in_shape),dict(point=arc_point(center,radius,start+sweep/2),point_kind='curve_midpoint',on_geometry=True)],'analytic_curve_points')
+                if kind=='CIRCLE_SOLID':
+                    contours[0]['filled']=True
+                    if r['base']['pen_style']==105:
+                        inner=r['solid_mode']*scale
+                        contours.append(dict(kind='circle',center=center,radius=inner,start_angle=0.,sweep_angle=-TAU,closed=True,role='hole'))
+                    elif not full:
+                        a,b=arc_point(center,radius,start),arc_point(center,radius,start+sweep)
+                        contours.append(dict(kind='polyline',points=[b,a],closed=False,role='chord'))
+                out['contours']=exact(contours,'analytic_curve_and_qualified_fill_boundary')
+                if 'segments'in self.fields:
+                    seg=self.curve_segments(center,radius,start,sweep,full)
+                    if seg['status']=='approximate'and kind=='CIRCLE_SOLID':
+                        if r['base']['pen_style']==105:
+                            second=self.curve_segments(center,inner,0.,-TAU,True)
+                            if second['status']=='approximate':seg['value']+=second['value'];seg['max_deviation']=max(seg['max_deviation'],second['max_deviation'])
+                            else:seg=unknown(second['reason'])
+                        elif not full:
+                            closing=self.segments([dict(start=arc_point(center,radius,start+sweep),end=arc_point(center,radius,start))])
+                            if closing['status']=='exact':seg['value']+=closing['value']
+                            else:seg=unknown(closing['reason'])
+                    out['segments']=seg
+            else:raise ValueError('Geometry kind is not verified: '+str(kind))
+        except (ValueError,KeyError,TypeError,OverflowError)as exc:
+            if isinstance(exc,GeometryLimit):raise
+            for field in ('bbox','segments','contours'):
+                if out[field]['status']=='not_requested':out[field]=unknown(exc)
+            if out['center']['status']=='not_requested':out['center']=unknown(exc)
+            if out['representative_points']['status']=='not_requested':out['representative_points']=unknown(exc)
+        return out