refactor: excel parse
This commit is contained in:
Blizzard
@@ -0,0 +1,455 @@
|
||||
# Copyright (c) 2019-2024, Manfred Moitzi
|
||||
# License: MIT-License
|
||||
from __future__ import annotations
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Iterable,
|
||||
Iterator,
|
||||
cast,
|
||||
Union,
|
||||
Optional,
|
||||
)
|
||||
from contextlib import contextmanager
|
||||
import logging
|
||||
from ezdxf.lldxf import validator, const
|
||||
from ezdxf.lldxf.attributes import (
|
||||
DXFAttr,
|
||||
DXFAttributes,
|
||||
DefSubclass,
|
||||
RETURN_DEFAULT,
|
||||
group_code_mapping,
|
||||
)
|
||||
from ezdxf.audit import AuditError
|
||||
from .dxfentity import base_class, SubclassProcessor, DXFEntity
|
||||
from .dxfobj import DXFObject
|
||||
from .factory import register_entity
|
||||
from .objectcollection import ObjectCollection
|
||||
from .copy import default_copy, CopyNotSupported
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from ezdxf.audit import Auditor
|
||||
from ezdxf.document import Drawing
|
||||
from ezdxf.entities import DXFNamespace, Dictionary
|
||||
from ezdxf.entitydb import EntityDB
|
||||
from ezdxf.layouts import Layouts
|
||||
from ezdxf.lldxf.tagwriter import AbstractTagWriter
|
||||
|
||||
__all__ = ["DXFGroup", "GroupCollection"]
|
||||
logger = logging.getLogger("ezdxf")
|
||||
|
||||
acdb_group = DefSubclass(
|
||||
"AcDbGroup",
|
||||
{
|
||||
# Group description
|
||||
"description": DXFAttr(300, default=""),
|
||||
# 1 = Unnamed
|
||||
# 0 = Named
|
||||
"unnamed": DXFAttr(
|
||||
70,
|
||||
default=1,
|
||||
validator=validator.is_integer_bool,
|
||||
fixer=RETURN_DEFAULT,
|
||||
),
|
||||
# 1 = Selectable
|
||||
# 0 = Not selectable
|
||||
"selectable": DXFAttr(
|
||||
71,
|
||||
default=1,
|
||||
validator=validator.is_integer_bool,
|
||||
fixer=RETURN_DEFAULT,
|
||||
),
|
||||
# 340: Hard-pointer handle to entity in group (one entry per object)
|
||||
},
|
||||
)
|
||||
acdb_group_group_codes = group_code_mapping(acdb_group)
|
||||
GROUP_ITEM_CODE = 340
|
||||
|
||||
|
||||
@register_entity
|
||||
class DXFGroup(DXFObject):
|
||||
"""Groups are not allowed in block definitions, and each entity can only
|
||||
reside in one group, so cloning of groups creates also new entities.
|
||||
|
||||
"""
|
||||
|
||||
DXFTYPE = "GROUP"
|
||||
DXFATTRIBS = DXFAttributes(base_class, acdb_group)
|
||||
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
self._handles: set[str] = set() # only needed at the loading stage
|
||||
self._data: list[DXFEntity] = []
|
||||
|
||||
def copy(self, copy_strategy=default_copy):
|
||||
raise CopyNotSupported("Copying of GROUP not supported.")
|
||||
|
||||
def load_dxf_attribs(
|
||||
self, processor: Optional[SubclassProcessor] = None
|
||||
) -> DXFNamespace:
|
||||
dxf = super().load_dxf_attribs(processor)
|
||||
if processor:
|
||||
tags = processor.fast_load_dxfattribs(
|
||||
dxf, acdb_group_group_codes, 1, log=False
|
||||
)
|
||||
self.load_group(tags)
|
||||
return dxf
|
||||
|
||||
def load_group(self, tags):
|
||||
for code, value in tags:
|
||||
if code == GROUP_ITEM_CODE:
|
||||
# First store handles, because at this point, objects
|
||||
# are not stored in the EntityDB:
|
||||
self._handles.add(value)
|
||||
|
||||
def preprocess_export(self, tagwriter: AbstractTagWriter) -> bool:
|
||||
# remove invalid entities
|
||||
assert self.doc is not None
|
||||
self.purge(self.doc)
|
||||
# export GROUP only if all entities reside on the same layout
|
||||
if not all_entities_on_same_layout(self._data):
|
||||
raise const.DXFStructureError(
|
||||
"All entities have to be in the same layout and are not allowed"
|
||||
" to be in a block layout."
|
||||
)
|
||||
return True
|
||||
|
||||
def export_entity(self, tagwriter: AbstractTagWriter) -> None:
|
||||
"""Export entity specific data as DXF tags."""
|
||||
super().export_entity(tagwriter)
|
||||
tagwriter.write_tag2(const.SUBCLASS_MARKER, acdb_group.name)
|
||||
self.dxf.export_dxf_attribs(tagwriter, ["description", "unnamed", "selectable"])
|
||||
self.export_group(tagwriter)
|
||||
|
||||
def export_group(self, tagwriter: AbstractTagWriter):
|
||||
for entity in self._data:
|
||||
tagwriter.write_tag2(GROUP_ITEM_CODE, entity.dxf.handle)
|
||||
|
||||
def __iter__(self) -> Iterator[DXFEntity]:
|
||||
"""Iterate over all DXF entities in :class:`DXFGroup` as instances of
|
||||
:class:`DXFGraphic` or inherited (LINE, CIRCLE, ...).
|
||||
|
||||
"""
|
||||
return (e for e in self._data if e.is_alive)
|
||||
|
||||
def __len__(self) -> int:
|
||||
"""Returns the count of DXF entities in :class:`DXFGroup`."""
|
||||
return len(self._data)
|
||||
|
||||
def __getitem__(self, item):
|
||||
"""Returns entities by standard Python indexing and slicing."""
|
||||
return self._data[item]
|
||||
|
||||
def __contains__(self, item: Union[str, DXFEntity]) -> bool:
|
||||
"""Returns ``True`` if item is in :class:`DXFGroup`. `item` has to be
|
||||
a handle string or an object of type :class:`DXFEntity` or inherited.
|
||||
|
||||
"""
|
||||
handle = item if isinstance(item, str) else item.dxf.handle
|
||||
return handle in set(self.handles())
|
||||
|
||||
def handles(self) -> Iterable[str]:
|
||||
"""Iterable of handles of all DXF entities in :class:`DXFGroup`."""
|
||||
return (entity.dxf.handle for entity in self)
|
||||
|
||||
def post_load_hook(self, doc: "Drawing"):
|
||||
super().post_load_hook(doc)
|
||||
db_get = doc.entitydb.get
|
||||
|
||||
def set_group_entities(): # post init command
|
||||
name = str(self)
|
||||
entities = filter_invalid_entities(self._data, self.doc, name)
|
||||
if not all_entities_on_same_layout(entities):
|
||||
self.clear()
|
||||
logger.debug(f"Cleared {name}, had entities from different layouts.")
|
||||
else:
|
||||
self._data = entities
|
||||
|
||||
def entities():
|
||||
for handle in self._handles:
|
||||
entity = db_get(handle)
|
||||
if entity and entity.is_alive:
|
||||
yield entity
|
||||
|
||||
# Filtering invalid DXF entities is not possible at this stage, just
|
||||
# store entities as they are:
|
||||
self._data = list(entities())
|
||||
del self._handles # all referenced entities are stored in data
|
||||
return set_group_entities
|
||||
|
||||
@contextmanager # type: ignore
|
||||
def edit_data(self) -> list[DXFEntity]: # type: ignore
|
||||
"""Context manager which yields all the group entities as
|
||||
standard Python list::
|
||||
|
||||
with group.edit_data() as data:
|
||||
# add new entities to a group
|
||||
data.append(modelspace.add_line((0, 0), (3, 0)))
|
||||
# remove last entity from a group
|
||||
data.pop()
|
||||
|
||||
"""
|
||||
data = list(self)
|
||||
yield data
|
||||
self.set_data(data)
|
||||
|
||||
def _validate_entities(self, entities: Iterable[DXFEntity]) -> list[DXFEntity]:
|
||||
assert self.doc is not None
|
||||
entities = list(entities)
|
||||
valid_entities = filter_invalid_entities(entities, self.doc, str(self))
|
||||
if len(valid_entities) != len(entities):
|
||||
raise const.DXFStructureError("invalid entities found")
|
||||
if not all_entities_on_same_layout(valid_entities):
|
||||
raise const.DXFStructureError(
|
||||
"All entities have to be in the same layout and are not allowed"
|
||||
" to be in a block layout."
|
||||
)
|
||||
return valid_entities
|
||||
|
||||
def set_data(self, entities: Iterable[DXFEntity]) -> None:
|
||||
"""Set `entities` as new group content, entities should be an iterable of
|
||||
:class:`DXFGraphic` (LINE, CIRCLE, ...).
|
||||
|
||||
Raises:
|
||||
DXFValueError: not all entities are located on the same layout (modelspace
|
||||
or any paperspace layout but not block)
|
||||
|
||||
"""
|
||||
valid_entities = self._validate_entities(entities)
|
||||
self.clear()
|
||||
self._add_group_reactor(valid_entities)
|
||||
self._data = valid_entities
|
||||
|
||||
def extend(self, entities: Iterable[DXFEntity]) -> None:
|
||||
"""Add `entities` to :class:`DXFGroup`, entities should be an iterable of
|
||||
:class:`DXFGraphic` (LINE, CIRCLE, ...).
|
||||
|
||||
Raises:
|
||||
DXFValueError: not all entities are located on the same layout (modelspace
|
||||
or any paperspace layout but not block)
|
||||
|
||||
"""
|
||||
valid_entities = self._validate_entities(entities)
|
||||
handles = set(self.handles())
|
||||
valid_entities = [e for e in valid_entities if e.dxf.handle not in handles]
|
||||
self._add_group_reactor(valid_entities)
|
||||
self._data.extend(valid_entities)
|
||||
|
||||
def clear(self) -> None:
|
||||
"""Remove all entities from :class:`DXFGroup`, does not delete any
|
||||
drawing entities referenced by this group.
|
||||
|
||||
"""
|
||||
# TODO: remove handle of GROUP entity from reactors of entities #1085
|
||||
self._remove_group_reactor(self._data)
|
||||
self._data = []
|
||||
|
||||
def _add_group_reactor(self, entities: list[DXFEntity]) -> None:
|
||||
group_handle = self.dxf.handle
|
||||
for entity in entities:
|
||||
entity.append_reactor_handle(group_handle)
|
||||
|
||||
def _remove_group_reactor(self, entities: list[DXFEntity]) -> None:
|
||||
group_handle = self.dxf.handle
|
||||
for entity in entities:
|
||||
entity.discard_reactor_handle(group_handle)
|
||||
|
||||
def audit(self, auditor: Auditor) -> None:
|
||||
"""Remove invalid entities from :class:`DXFGroup`.
|
||||
|
||||
Invalid entities are:
|
||||
|
||||
- deleted entities
|
||||
- all entities which do not reside in model- or paper space
|
||||
- all entities if they do not reside in the same layout
|
||||
|
||||
"""
|
||||
entity_count = len(self)
|
||||
assert auditor.doc is not None
|
||||
# Remove destroyed or invalid entities:
|
||||
self.purge(auditor.doc)
|
||||
removed_entity_count = entity_count - len(self)
|
||||
if removed_entity_count > 0:
|
||||
auditor.fixed_error(
|
||||
code=AuditError.INVALID_GROUP_ENTITIES,
|
||||
message=f"Removed {removed_entity_count} invalid entities from {str(self)}",
|
||||
)
|
||||
if not all_entities_on_same_layout(self._data):
|
||||
auditor.fixed_error(
|
||||
code=AuditError.GROUP_ENTITIES_IN_DIFFERENT_LAYOUTS,
|
||||
message=f"Cleared {str(self)}, not all entities are located in "
|
||||
f"the same layout.",
|
||||
)
|
||||
self.clear()
|
||||
|
||||
group_handle = self.dxf.handle
|
||||
if not group_handle:
|
||||
return
|
||||
for entity in self._data:
|
||||
if entity.reactors is None or group_handle not in entity.reactors:
|
||||
auditor.fixed_error(
|
||||
code=AuditError.MISSING_PERSISTENT_REACTOR,
|
||||
message=f"Entity {entity} in group #{group_handle} does not have "
|
||||
f"group as persistent reactor",
|
||||
)
|
||||
entity.append_reactor_handle(group_handle)
|
||||
|
||||
def purge(self, doc: Drawing) -> None:
|
||||
"""Remove invalid group entities."""
|
||||
self._data = filter_invalid_entities(
|
||||
entities=self._data, doc=doc, group_name=str(self)
|
||||
)
|
||||
|
||||
|
||||
def filter_invalid_entities(
|
||||
entities: Iterable[DXFEntity],
|
||||
doc: Drawing,
|
||||
group_name: str = "",
|
||||
) -> list[DXFEntity]:
|
||||
assert doc is not None
|
||||
db = doc.entitydb
|
||||
valid_owner_handles = valid_layout_handles(doc.layouts)
|
||||
valid_entities: list[DXFEntity] = []
|
||||
for entity in entities:
|
||||
if entity.is_alive and _has_valid_owner(
|
||||
entity.dxf.owner, db, valid_owner_handles
|
||||
):
|
||||
valid_entities.append(entity)
|
||||
elif group_name:
|
||||
if entity.is_alive:
|
||||
logger.debug(f"{str(entity)} in {group_name} has an invalid owner.")
|
||||
else:
|
||||
logger.debug(f"Removed deleted entity in {group_name}")
|
||||
return valid_entities
|
||||
|
||||
|
||||
def _has_valid_owner(owner: str, db: EntityDB, valid_owner_handles: set[str]) -> bool:
|
||||
# no owner -> no layout association
|
||||
if owner is None:
|
||||
return False
|
||||
# The check for owner.dxf.layout != "0" is not sufficient #521
|
||||
if valid_owner_handles and owner not in valid_owner_handles:
|
||||
return False
|
||||
layout = db.get(owner)
|
||||
# owner layout does not exist or is destroyed -> no layout association
|
||||
if layout is None or not layout.is_alive:
|
||||
return False
|
||||
# If "valid_owner_handles" is not empty, entities located on BLOCK
|
||||
# layouts are already removed.
|
||||
# DXF attribute block_record.layout is "0" if entity is located in a
|
||||
# block definition, which is invalid:
|
||||
return layout.dxf.layout != "0"
|
||||
|
||||
|
||||
def all_entities_on_same_layout(entities: Iterable[DXFEntity]):
|
||||
"""Check if all entities are on the same layout (model space or any paper
|
||||
layout but not block).
|
||||
|
||||
"""
|
||||
owners = set(entity.dxf.owner for entity in entities)
|
||||
# 0 for no entities; 1 for all entities on the same layout
|
||||
return len(owners) < 2
|
||||
|
||||
|
||||
def valid_layout_handles(layouts: Layouts) -> set[str]:
|
||||
"""Returns valid layout keys for group entities."""
|
||||
return set(layout.layout_key for layout in layouts if layout.is_any_layout)
|
||||
|
||||
|
||||
class GroupCollection(ObjectCollection[DXFGroup]):
|
||||
def __init__(self, doc: Drawing):
|
||||
super().__init__(doc, dict_name="ACAD_GROUP", object_type="GROUP")
|
||||
self._next_unnamed_number = 0
|
||||
|
||||
def groups(self) -> Iterator[DXFGroup]:
|
||||
"""Iterable of all existing groups."""
|
||||
for name, group in self:
|
||||
yield group
|
||||
|
||||
def next_name(self) -> str:
|
||||
name = self._next_name()
|
||||
while name in self:
|
||||
name = self._next_name()
|
||||
return name
|
||||
|
||||
def _next_name(self) -> str:
|
||||
self._next_unnamed_number += 1
|
||||
return f"*A{self._next_unnamed_number}"
|
||||
|
||||
def new(
|
||||
self,
|
||||
name: Optional[str] = None,
|
||||
description: str = "",
|
||||
selectable: bool = True,
|
||||
) -> DXFGroup:
|
||||
r"""Creates a new group. If `name` is ``None`` an unnamed group is
|
||||
created, which has an automatically generated name like "\*Annnn".
|
||||
Group names are case-insensitive.
|
||||
|
||||
Args:
|
||||
name: group name as string
|
||||
description: group description as string
|
||||
selectable: group is selectable if ``True``
|
||||
|
||||
"""
|
||||
if name is not None and name in self:
|
||||
raise const.DXFValueError(f"GROUP '{name}' already exists.")
|
||||
|
||||
if name is None:
|
||||
name = self.next_name()
|
||||
unnamed = 1
|
||||
else:
|
||||
unnamed = 0
|
||||
# The group name isn't stored in the group entity itself.
|
||||
dxfattribs = {
|
||||
"description": description,
|
||||
"unnamed": unnamed,
|
||||
"selectable": int(bool(selectable)),
|
||||
}
|
||||
return cast(DXFGroup, self._new(name, dxfattribs))
|
||||
|
||||
def delete(self, group: Union[DXFGroup, str]) -> None:
|
||||
"""Delete `group`, `group` can be an object of type :class:`DXFGroup`
|
||||
or a group name as string.
|
||||
|
||||
"""
|
||||
entitydb = self.doc.entitydb
|
||||
assert entitydb is not None
|
||||
# Delete group by name:
|
||||
if isinstance(group, str):
|
||||
name = group
|
||||
elif group.dxftype() == "GROUP":
|
||||
name = get_group_name(group, entitydb)
|
||||
else:
|
||||
raise TypeError(group.dxftype())
|
||||
|
||||
if name in self:
|
||||
super().delete(name)
|
||||
else:
|
||||
raise const.DXFValueError("GROUP not in group table registered.")
|
||||
|
||||
def audit(self, auditor: Auditor) -> None:
|
||||
"""Removes empty groups and invalid handles from all groups."""
|
||||
trash = []
|
||||
for name, group in self:
|
||||
group = cast(DXFGroup, group)
|
||||
group.audit(auditor)
|
||||
if not len(group): # remove empty group
|
||||
# do not delete groups while iterating over groups!
|
||||
trash.append(name)
|
||||
|
||||
# now delete empty groups
|
||||
for name in trash:
|
||||
auditor.fixed_error(
|
||||
code=AuditError.REMOVE_EMPTY_GROUP,
|
||||
message=f'Removed empty group "{name}".',
|
||||
)
|
||||
self.delete(name)
|
||||
|
||||
|
||||
def get_group_name(group: DXFGroup, db: EntityDB) -> str:
|
||||
"""Get name of `group`."""
|
||||
group_table = cast("Dictionary", db[group.dxf.owner])
|
||||
for name, entity in group_table.items():
|
||||
if entity is group:
|
||||
return name
|
||||
return ""
|
||||
Reference in New Issue
Block a user