Umut CANandClaude Opus 5
ca1c79fd01
Release / test (full, windows-latest, 3.11) (push) Canceled after 0s
Release / test (pdf, ubuntu-latest, 3.11) (push) Canceled after 0s
Release / test (pdf, ubuntu-latest, 3.12) (push) Canceled after 0s
Release / build (push) Canceled after 0s
Release / publish-pypi (push) Canceled after 0s
Release / github-release (push) Canceled after 0s
Every one of these was reported ok/clean to the caller while being wrong.
Silently wrong numbers
- selection_filter(min_area) read `entity.dxf.get("area", 0.0)` for SOLID,
TRACE and HATCH, none of which carry that attribute, so every hatch
measured 0.0. A 1600 mm^2 hatch was excluded by min_area=1.0 while
`filtered_by` asserted the filter had run, and COM (which reads ActiveX
.Area) returned a different selection for the same call. It now answers
from the measurement `entity_measure` uses, so the two cannot disagree.
- Every headless dimension rendered through ezdxf's bare `Standard` style:
1.0 mm text with a comma decimal marker, against ISO 3098's 2.5 mm minimum
and ISO 129's point -- while the document header itself said $DIMTXT 2.5.
`ezdxf.new(setup=True)` is not the fix; measured, it renders a 100 mm
dimension as "10000". The attributes are now stored explicitly.
- Saving writes `dimrnd = 0.0` onto the Standard style, and ezdxf applies
`xround(value, dimrnd)` whenever the attribute is present at all --
`xround(33.333, 0.0)` is 33. So on any reopened file, including one this
server saved, every dimension was rounded to a whole unit before DIMDEC
formatted it: a 12.75 mm feature dimensioned 13. AutoCAD means DIMRND 0 as
*no* rounding; the sentinel is now discarded at every load site, and a real
0.5 mm rounding is left alone.
- The DIM* header fold gave out-of-range values teeth they did not have when
they died in the header: dim_decimals=-1 returned ok and then killed the
next dimension with `ValueError: Format specifier missing precision` from
inside ezdxf, and 40 printed forty digits of float noise onto the sheet.
Ranges are now AutoCAD's own (DIMDEC 0-8, DIMZIN 0-15, lengths positive).
Security
- security.py recorded the policy as "sanitize_command and sanitize_lisp each
have exactly ONE caller ... the policy is scoped to the CHANNEL". The
premise was false. `_ensure_linetype_loaded` and `ComBackend.linetype_load`
build `_-LINETYPE _LOAD {name} {file}` and hand it to SendCommand, which
treats a newline and ';' as segment separators -- so a `linetype=` argument
carrying either injected further AutoCAD commands, and the 36-verb denylist
never saw that channel. Guarded with the DXF symbol-name rule (the
injection characters fall out of it rather than being enumerated) plus
validate_path for the file argument, which was also the one path-taking
tool reaching the filesystem unchecked. The policy comment is corrected.
Gates that could not see
- drawing_critique returned zero issues on a quarantined document: all seven
checks wrapped their backend call in a bare `except Exception`. CLAUDE.md
rule 7 makes that call the gate an agent is told to trust. Only the
quarantine now escapes; an ordinary broken check still degrades.
`_check_dimension_legibility` also read `_doc` directly from the event loop
thread, missing the gate and performing exactly the unsynchronised access
the quarantine exists to prevent. `construction_clear` answered
"deleted: 0" -- there was nothing to clear -- for the same reason.
- The iso128 focus checked layer lineweights only, so a sheet lettered at
1.0 mm critiqued clean. It now reads the effective dimension height and
separator, header-then-style, in the order the renderer resolves.
- check_doc_numbers.py derived five values it never checked, and those were
the ones that had drifted. The collected-test count (README said 1274, the
tree had 1369) and the A/B pass-rate and Fixed columns are now gated.
- benchmarks/README.md's v1.4.0 table was impossible on its face -- 21
passing plus 5 fixed is 26, not 24 -- and contradicted the report it
linked, because `ab-v1.4.0-vs-v1.5.0.json` was regenerated from a tree that
already carried the dimension fixes and so never measured the v1.5.0 tag.
Replaced with a real run: ab-v1.4.0-vs-v1.5.1.json, 21/26 -> 26/26.
Release gate
- release.yml ran one ubuntu/3.11 lane, so a Windows-only defect could reach
PyPI with no Windows job having executed. That is not hypothetical: v1.5.0
shipped `except pywintypes.com_error` raising NameError wherever pywin32 is
absent. It now runs the same three lanes as ci.yml, Windows included.
1368 passed, 1 xfailed. ruff clean. Tool inventory and all 16 gated document
numbers match the tree.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
72 lines
2.6 KiB
Python
72 lines
2.6 KiB
Python
"""A setting the renderer cannot use must be refused, not reported applied.
|
|
|
|
Folding the DIM* header variables into the per-dimension override closed a
|
|
silent no-op and opened a louder failure: values that used to die harmlessly in
|
|
the header now reach ezdxf's formatter. Measured before this guard existed:
|
|
|
|
* ``dim_decimals=-1`` returned ``ok: True`` and the *next* dimension of four of
|
|
the five kinds died with ``ValueError: Format specifier missing precision``,
|
|
from inside the renderer, nowhere near the call that caused it.
|
|
* ``dim_decimals=40`` returned ``ok: True`` and printed
|
|
``33.3329999999999984083842718973755836486816`` onto the drawing.
|
|
* ``dim_text_height=-3.0`` returned ``ok: True`` and changed nothing.
|
|
|
|
AutoCAD's own ranges are the reference: DIMDEC 0-8, DIMZIN a 0-15 bitmask, and
|
|
the two lengths strictly positive. `applied` has to mean applied.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import pytest
|
|
|
|
pytestmark = pytest.mark.asyncio
|
|
|
|
|
|
@pytest.mark.parametrize("value", [-1, 9, 40])
|
|
async def test_out_of_range_dim_decimals_is_refused(backend, value):
|
|
result = await backend.drawing_settings({"dim_decimals": value})
|
|
|
|
assert result["ok"] is False
|
|
assert "dim_decimals" in result["errors"]
|
|
assert "dim_decimals" not in result.get("applied", {})
|
|
|
|
|
|
async def test_a_refused_dim_decimals_cannot_break_the_next_dimension(backend):
|
|
"""The crash was the point: the bad value reached the formatter."""
|
|
await backend.drawing_settings({"dim_decimals": -1})
|
|
|
|
dim = await backend.dimension_linear(0, 0, 33.333, 0, 16, -30)
|
|
|
|
assert dim.handle
|
|
|
|
|
|
@pytest.mark.parametrize("value", [0, 2, 8])
|
|
async def test_dim_decimals_in_range_is_still_accepted(backend, value):
|
|
result = await backend.drawing_settings({"dim_decimals": value})
|
|
|
|
assert result["ok"] is True, result.get("errors")
|
|
|
|
|
|
@pytest.mark.parametrize("key", ["dim_text_height", "dim_arrow_size"])
|
|
@pytest.mark.parametrize("value", [0.0, -3.0])
|
|
async def test_a_non_positive_length_is_refused(backend, key, value):
|
|
result = await backend.drawing_settings({key: value})
|
|
|
|
assert result["ok"] is False
|
|
assert key in result["errors"]
|
|
|
|
|
|
@pytest.mark.parametrize("value", [-1, 16, 999])
|
|
async def test_zero_suppression_outside_the_bitmask_is_refused(backend, value):
|
|
result = await backend.drawing_settings({"zero_suppression": value})
|
|
|
|
assert result["ok"] is False
|
|
assert "zero_suppression" in result["errors"]
|
|
|
|
|
|
async def test_one_bad_key_does_not_discard_the_good_ones(backend):
|
|
result = await backend.drawing_settings({"dim_text_height": 5.0, "dim_decimals": -1})
|
|
|
|
assert result["applied"]["dim_text_height"] == 5.0
|
|
assert "dim_decimals" in result["errors"]
|