def add_tags(self, tags: ExtendedTags) -> str:
try:
handle = tags.get_handle()
except DXFValueError: # create new handle
handle = self.get_unique_handle()
handle_code = 105 if tags.dxftype() == 'DIMSTYLE' else 5 # legacy shit!!!
tags.noclass.insert(1, DXFTag(handle_code, handle)) # handle should be the 2. tag
self.__setitem__(handle, tags)
return handle
def __init__(self, tags: ExtendedTags, dxfversion=None):
if len(tags.subclasses) == 0:
raise ValueError('Invalid tags.')
self.subclasses = list(tags.subclasses) # type: List[Tags] # copy subclasses
self.dxfversion = dxfversion
# DXF R12 and prior have no subclass marker system, all tags of an entity in one flat list
# Where later DXF versions have at least 2 subclasses base_class and AcDbEntity
# Exception CLASS has also only one subclass and no subclass marker, handled as DXF R12 entity
self.r12 = (dxfversion == DXF12) or (len(self.subclasses) == 1)
self.name = tags.dxftype()
try:
self.handle = tags.get_handle()
except DXFValueError:
self.handle = '<?>'
def tag_processor(tags: ExtendedTags) -> ExtendedTags:
subclass = tags.get_subclass('AcDbSubDMesh')
handle = tags.get_handle()
convert_and_replace_tags(subclass, handle)
return tags
class Table:
def __init__(self, entities: Iterable[Tags], drawing: 'Drawing'):
self._table_header = None
self._dxfname = None
self._drawing = drawing
self._table_entries = []
self._build_table_entries(iter(entities))
# start public interface
@staticmethod
def key(entity: Union[str, 'DXFEntity']) -> str:
if not isinstance(entity, str):
entity = entity.dxf.name
return entity.lower() # table key is lower case
@property
def name(self) -> str:
return tablename(self._dxfname)
def has_entry(self, name: str) -> bool:
""" Check if an table-entry 'name' exists. """
key = self.key(name)
return any(self.key(entry) == key for entry in self)
__contains__ = has_entry
def new(self, name: str, dxfattribs: dict = None) -> 'DXFEntity':
if self.has_entry(name):
raise DXFTableEntryError('%s %s already exists!' % (self._dxfname, name))
dxfattribs = dxfattribs or {}
dxfattribs['name'] = name
return self.new_entry(dxfattribs)
def get(self, name: str) -> 'DXFEntity':
""" Get table-entry by name as WrapperClass(). """
key = self.key(name)
for entry in iter(self):
if self.key(entry) == key:
return entry
raise DXFTableEntryError(name)
def remove(self, name: str) -> None:
""" Remove table-entry from table and entitydb by name. """
entry = self.get(name)
handle = entry.dxf.handle
self.remove_handle(handle)
def __len__(self) -> int:
return len(self._table_entries)
def __iter__(self) -> Iterable['DXFEntity']:
for handle in self._table_entries:
yield self.get_table_entry_wrapper(handle)
# end public interface
def _build_table_entries(self, entities: Iterator[Tags]) -> None:
table_head = next(entities)
if table_head[0].value != 'TABLE':
raise DXFStructureError("Critical structure error in TABLES section.")
self._dxfname = table_head[1].value
self._table_header = ExtendedTags(table_head) # do not store the table head in the entity database
for table_entry in entities:
self._append_entry_handle(table_entry.get_handle())
@property
def entitydb(self) -> 'EntityDB':
return self._drawing.entitydb
@property
def handles(self) -> 'HandleGenerator':
return self._drawing.entitydb.handles
@property
def dxffactory(self) -> 'DXFFactoryType':
return self._drawing.dxffactory
def _iter_table_entries_as_tags(self) -> Iterable[ExtendedTags]:
""" Iterate over table-entries as Tags(). """
return (self.entitydb[handle] for handle in self._table_entries)
def new_entry(self, dxfattribs: dict) -> 'DXFEntity':
""" Create new table-entry of type 'self._dxfname', and add new entry
to table.
Does not check if an entry dxfattribs['name'] already exists!
Duplicate entries are possible for Viewports.
"""
handle = self.handles.next()
entry = self.dxffactory.new_entity(self._dxfname, handle, dxfattribs)
self._add_entry(entry)
return entry
def duplicate_entry(self, name: str, new_name: str) -> 'DXFEntity':
entry = self.get(name)
xtags = self.entitydb.duplicate_tags(entry.tags)
new_entity = self.dxffactory.wrap_entity(xtags)
new_entity.dxf.name = new_name
self._add_entry(new_entity)
return new_entity
def _add_entry(self, entry: Union[ExtendedTags, 'DXFEntity']) -> None:
""" Add table-entry to table and entitydb. """
if isinstance(entry, ExtendedTags):
tags = entry
else:
tags = entry.tags
handle = self.entitydb.add_tags(tags)
self._append_entry_handle(handle)
def _append_entry_handle(self, handle: str) -> None:
if handle not in self._table_entries:
self._table_entries.append(handle)
def get_table_entry_wrapper(self, handle: str) -> 'DXFEntity':
tags = self.entitydb[handle]
return self.dxffactory.wrap_entity(tags)
def write(self, tagwriter: 'TagWriter') -> None:
""" Write DXF representation to stream, stream opened with mode='wt'. """
def prologue():
self._update_owner_handles()
self._update_meta_data()
tagwriter.write_tags(self._table_header)
def content():
for tags in self._iter_table_entries_as_tags():
tagwriter.write_tags(tags)
def epilogue():
tagwriter.write_tag2(0, 'ENDTAB')
prologue()
content()
epilogue()
def _update_owner_handles(self) -> None:
if self._drawing.dxfversion <= 'AC1009':
return # no owner handles
owner_handle = self._table_header.get_handle()
for entry in iter(self):
if not entry.supports_dxf_attrib('owner'):
raise DXFAttributeError(repr(entry))
entry.dxf.owner = owner_handle
def _update_meta_data(self) -> None:
count = len(self)
if self._drawing.dxfversion > 'AC1009':
subclass = self._table_header.get_subclass('AcDbSymbolTable')
else:
subclass = self._table_header.noclass
subclass.set_first(DXFTag(70, count))
def remove_handle(self, handle: str) -> None:
""" Remove table-entry from table and entitydb by handle. """
self._table_entries.remove(handle)
del self.entitydb[handle]
def audit(self, auditor) -> None:
"""
Checks for table entries with same key.
"""
entries = sorted(self._table_entries, key=lambda e: self.key(e))
prev_key = None
for entry in entries:
key = self.key(entry)
if key == prev_key:
auditor.add_error(
code=Error.DUPLICATE_TABLE_ENTRY_NAME,
message="Duplicate table entry name '{1}' in table {0}".format(self.name, entry.dxf.name),
dxf_entity=self,
data=key,
)
prev_key = key
