def raw_pretty_print(filename, nocompile=True, legacy_mode=False):
try:
info = dxf_file_info(str(filename))
except IOError:
print("Unable to read DXF file '{}'.".format(filename))
sys.exit(1)
except DXFError as e:
print(str(e))
sys.exit(2)
with io.open(filename, mode='rt', encoding=info.encoding, errors='ignore') as dxf:
tagger = low_level_tagger(dxf)
if legacy_mode:
tagger = tag_reorder_layer(tagger)
if nocompile is False:
tagger = tag_compiler(tagger)
html_filename = filename.parent / (filename.stem + '.html')
try:
with io.open(html_filename, mode='wt', encoding='utf-8') as html:
html.write(rawpp(tagger, str(filename)))
except IOError:
print("IOError: can not write file '{}'.".format(html_filename))
except DXFStructureError as e:
print("DXFStructureError: {}".format(str(e)))
return html_filename
def safe_tag_loader(
stream: BinaryIO,
loader: Callable = None,
messages: List = None,
errors: str = 'surrogateescape',
) -> Iterable[DXFTag]:
""" Yields :class:``DXFTag`` objects from a bytes `stream`
(untrusted external source), skips all comment tags (group code == 999).
- Fixes unordered and invalid vertex tags.
- Pass :func:`synced_bytes_loader` as argument `loader` to brute force
load invalid tag structure.
Args:
stream: input data stream as bytes
loader: low level tag loader, default loader is :func:`bytes_loader`
messages: list to store error messages
errors: specify decoding error handler
- "surrogateescape" to preserve possible binary data (default)
- "ignore" to use the replacement char U+FFFD "\ufffd" for invalid data
- "strict" to raise an :class:`UnicodeDecodeError` exception for invalid data
"""
if loader is None:
loader = bytes_loader
tags, detector_stream = itertools.tee(loader(stream), 2)
encoding = detect_encoding(detector_stream)
# Apply repair filter:
tags = repair.tag_reorder_layer(tags)
tags = repair.filter_invalid_point_codes(tags)
return byte_tag_compiler(tags, encoding, messages=messages, errors=errors)
def read(stream: TextIO, legacy_mode: bool = False, dxfversion: str = None) -> 'Drawing':
""" Open an existing drawing. """
from .lldxf.tagger import low_level_tagger, tag_compiler
tagger = low_level_tagger(stream)
if legacy_mode:
if dxfversion is not None and dxfversion <= 'AC1009':
tagger = repair.filter_subclass_marker(tagger)
tagger = repair.tag_reorder_layer(tagger)
tagreader = tag_compiler(tagger)
return Drawing(tagreader)
def readfile(filename: str, legacy_mode: bool = False, compile_tags=True) -> Iterable[DXFTag]:
from ezdxf.lldxf.validator import is_dxf_file
if not is_dxf_file(filename):
raise IOError("File '{}' is not a DXF file.".format(filename))
info = dxf_file_info(filename)
fp = open(filename, mode='rt', encoding=info.encoding, errors='ignore')
tagger = low_level_tagger(fp)
if legacy_mode:
tagger = tag_reorder_layer(tagger)
if compile_tags:
tagger = tag_compiler(tagger)
return tagger
def readfile(filename: str,
legacy_mode: bool = False,
compile_tags=True,
is_binary_dxf=False) -> Iterable[DXFTag]:
if is_binary_dxf:
with open(filename, mode='rb') as fp:
data = fp.read()
tagger = binary_tags_loader(data)
else:
info = dxf_file_info(filename)
fp = open(filename, mode='rt', encoding=info.encoding, errors='ignore')
tagger = ascii_tags_loader(fp)
if legacy_mode:
tagger = tag_reorder_layer(tagger)
if compile_tags:
tagger = tag_compiler(iter(tagger))
return tagger
def safe_tag_loader(stream: BinaryIO,
loader: Callable = None) -> Iterable[DXFTag]:
""" Yields :class:``DXFTag`` objects from a bytes `stream`
(untrusted external source), skips all comment tags (group code == 999).
- Fixes unordered and invalid vertex tags.
- Pass :func:`synced_bytes_loader` as argument `loader` to brute force
load invalid tag structure.
Args:
stream: input data stream as bytes
loader: low level tag loader, default loader is :func:`bytes_loader`
"""
if loader is None:
loader = bytes_loader
tags, detector_stream = itertools.tee(loader(stream), 2)
encoding = detect_encoding(detector_stream)
# Apply repair filter:
tags = repair.tag_reorder_layer(tags)
tags = repair.filter_invalid_yz_point_codes(tags)
return byte_tag_compiler(tags, encoding)
def string_reorder_tagger(s):
return tag_reorder_layer(ascii_tags_loader(StringIO(s)))
def string_reorder_tagger(s):
return tag_reorder_layer(low_level_tagger(StringIO(s)))
