saptadi73/Addon-Odoo19
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First Commit

Browse Source
This commit is contained in:
saptadi73
2026-05-31 10:17:09 +07:00
commit 17a9c69379
4547 changed files with 1170384 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.venv/Lib/site-packages/ifcopenshell/entity_instance.py
+654
View File
@@ -0,0 +1,654 @@
# IfcOpenShell - IFC toolkit and geometry engine
# Copyright (C) 2021 Thomas Krijnen <thomas@aecgeeks.com>
#
# This file is part of IfcOpenShell.
#
# IfcOpenShell is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# IfcOpenShell is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with IfcOpenShell. If not, see <http://www.gnu.org/licenses/>.
from __future__ import annotations
import functools
import importlib
import itertools
import numbers
import operator
import subprocess
import sys
import time
from collections.abc import Callable, Sequence
from typing import TYPE_CHECKING, Any, NoReturn, TypeVar, Union, cast, overload
from . import ifcopenshell_wrapper, settings
if TYPE_CHECKING:
import ifcopenshell
try:
import logging
except ImportError:
logging = type("logger", (object,), {"exception": staticmethod(lambda s: print(s))})
T = TypeVar("T")
def set_derived_attribute(*args):
raise TypeError("Unable to set derived attribute")
def set_unsupported_attribute(*args):
raise TypeError("This is an unsupported attribute type")
# For every schema and its entities populate a list
# of functions for every entity attribute (including
# inherited attributes) to set that particular
# attribute by index.
# For example. IFC2X3.IfcWall with have a list of
# 9 methods. The first will point at
# ifcopenshell.ifcopenshell_wrapper.entity_instance.setArgumentAsString
# because the first attribute GlobalId ultimately
# is of type string.
# Previously, resolving the appropriate function was
# done for each invocation of __setitem__. Now this
# mapping is built once during initialization of the
# module.
MethodList = list[Callable[[ifcopenshell_wrapper.entity_instance, int, Any], Union[None, NoReturn]]]
"""List of setter methods for class attributes."""
_method_dict: dict[str, MethodList] = {}
"""Mapping of entity classes (e.g. 'IFC4.IfcWall') to MethodLists."""
def register_schema_attributes(schema: ifcopenshell_wrapper.schema_definition) -> None:
for decl in schema.declarations():
if hasattr(decl, "argument_types"):
fq_name = ".".join((schema.name(), decl.name()))
# get type strings as reported by IfcOpenShell C++
type_strs = decl.argument_types()
type_strs = cast(Sequence[str], type_strs)
# convert case for setter function
type_strs = [x.title().replace(" ", "") for x in type_strs]
# binary and enumeration are passed from python as string as well
type_strs = [x.replace("Binary", "String") for x in type_strs]
type_strs = [x.replace("Enumeration", "String") for x in type_strs]
# prefix to get method names
fn_names = ["setArgumentAs" + x for x in type_strs]
# resolve to actual functions in wrapper
functions = [
(
set_derived_attribute
if mname == "setArgumentAsDerived"
else (
set_unsupported_attribute
if mname == "setArgumentAsUnknown"
else getattr(ifcopenshell_wrapper.entity_instance, mname)
)
)
for mname in fn_names
]
_method_dict[fq_name] = functions
for nm in ifcopenshell_wrapper.schema_names():
schema = ifcopenshell_wrapper.schema_by_name(nm)
register_schema_attributes(schema)
class entity_instance:
"""Represents an entity (wall, slab, property, etc) of an IFC model
An IFC model consists of entities. Examples of entities include walls,
slabs, doors and so on. Entities can also be non-physical things, like
properties, systems, construction tasks, colours, geometry, and more.
Entities are defined through an **IFC Class**. There are hundreds of **IFC
Classes** defined as part of the ISO standard by the buildingSMART
International organisation. The **IFC Class** defines the attributes of an
entity, as well as the data types and whether or not an attribute is
mandatory or optional.
IfcOpenShell's API dynamically implements the IFC schema. You will not find
documentation about available **IFC Classes**, or what attributes they
have. Please consult the buildingSMART official documentation or start
reading :doc:`/introduction/introduction_to_ifc`.
In addition to the Python methods you see documented here, an instantiated
entity_instance will have attributes defined by its IFC class. For example,
an entity instance which is an IfcWall class will have a ``Name``
attribute, and an IfcColourRgb will have a ``Red`` attribute. Please
consult the buildingSMART official documentation.
Example:
.. code:: python
model = ifcopenshell.open(file_path)
walls = model.by_type("IfcWall")
wall = walls[0]
print(wall) # #38=IFCWALL('2MEinnTPbCMwLOgceaQZFu',$,$,'My Wall',$,#52,#47,$,$);
print(wall.is_a()) # IfcWall
# Note: the `Name` attribute is dynamic, based on the IFC class.
print(wall.Name) # My Wall
# Attributes are ordered and may also be accessed via index.
print(wall[3]) # My Wall
print(wall.__class__) # <class 'ifcopenshell.entity_instance'>
"""
wrapped_data: ifcopenshell_wrapper.entity_instance
method_list: Union[MethodList, None] = None
def __init__(
self,
e: Union[ifcopenshell_wrapper.entity_instance, tuple[str, str]],
file: Union[ifcopenshell.file, None] = None,
):
"""
:param e: Wrapper's ``entity_instance`` or a tuple ``(schema_identifier, ifc_class)``.
"""
# Instances of this class will be created and removed very often,
# so it's important to keep it very optimized.
if isinstance(e, tuple):
e = ifcopenshell_wrapper.new_IfcBaseClass(*e)
object.__setattr__(self, "wrapped_data", e)
# Make sure the file is not gc'ed while we have live instances
e.file = file
def __del__(self):
"""
#2471 while the precise chain of action is unclear, creating
instance references prevents file gc, even with all instance
refs deleted. This is a work-around for that.
"""
# Avoid infinite recursion if entity is failed to initialize
# and wrapped_data is unset. Hacky since we override
# both __dict__ and __dir__.
try:
wrapped_data = object.__getattribute__(self, "wrapped_data")
wrapped_data.file = None
except AttributeError:
return
@property
def file(self):
# ugh circular imports, name collisions
from . import file
return file.from_pointer(self.wrapped_data.file_pointer())
def __getattr__(self, name: str) -> Any:
"""
Any aggregate attributes (e.g. `SET`) are returns as Python tuples.
Inverse attributes are always returned as tuples, even it's not a set origially in IFC
(e.g. IfcFeatureElementSubtraction.VoidsElements)
"""
INVALID, FORWARD, INVERSE = range(3)
attr_cat = self.wrapped_data.get_attribute_category(name)
if attr_cat == FORWARD:
idx = self.wrapped_data.get_argument_index(name)
if _method_dict[self.is_a(True)][idx] != set_derived_attribute:
# A bit ugly, but we fall through to derived attribute handling below
return entity_instance.wrap_value(self.wrapped_data.get_argument(idx), self.wrapped_data.file)
elif attr_cat == INVERSE:
vs = entity_instance.wrap_value(self.wrapped_data.get_inverse(name), self.wrapped_data.file)
if settings.unpack_non_aggregate_inverses:
schema_name = self.wrapped_data.is_a(True).split(".")[0]
ent: ifcopenshell_wrapper.entity
ent = ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(self.is_a())
inv = next(i for i in ent.all_inverse_attributes() if i.name() == name)
if (inv.bound1(), inv.bound2()) == (-1, -1):
if vs:
vs = vs[0]
else:
vs = None
return vs
# derived attribute perhaps?
schema_name = self.wrapped_data.is_a(True).split(".")[0]
try:
rules = importlib.import_module(f"ifcopenshell.express.rules.{schema_name}")
except:
import os
current_dir_files = {fn.lower(): fn for fn in os.listdir(".")}
exp_filename = schema_name.lower() + ".exp"
schema_path = current_dir_files.get(exp_filename)
if schema_path is None:
raise Exception(
f"Couldn't find express file '{schema_name.lower()}.exp' in the current folder: '{os.getcwd()}'."
)
fn = schema_path[:-4] + ".py"
if not os.path.exists(fn):
subprocess.run(
[sys.executable, "-m", "ifcopenshell.express.rule_compiler", schema_path, fn], check=True
)
time.sleep(1.0)
rules = importlib.import_module(schema_name)
def yield_supertypes():
decl = ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(self.is_a())
while decl:
yield decl.name()
decl = decl.supertype()
for sty in yield_supertypes():
fn = getattr(rules, f"calc_{sty}_{name}", None)
if fn:
return fn(self)
if attr_cat != FORWARD:
raise AttributeError(
"entity instance of type '%s' has no attribute '%s'" % (self.wrapped_data.is_a(True), name)
)
@staticmethod
def walk(f: Callable[[Any], bool], g: Callable[[Any], Any], value: Any) -> Any:
"""Applies a transformation to `value` based on a given condition.
If value is a nested structure (e.g., a list or a tuple) will apply
transformation to it's elements.
:param f: A callable that takes a single argument and returns a boolean
value. It represents the condition.
:param g: A callable that takes a single argument and returns a
transformed value. It represents the transformation.
:param value: Any object, the input value to be processed
:return: Transformed value
Example:
.. code:: python
# Define condition and transformation functions
condition = lambda v: v == old
transform = lambda v: new
# Usage example
attribute_value = element.RelatedElements
print(old in attribute_value, new in attribute_value) # True, False
result = element.walk(condition, transform, element.RelatedElements)
print(old in attribute_value, new in attribute_value) # False, True
"""
if isinstance(value, (tuple, list)):
return tuple(map(functools.partial(entity_instance.walk, f, g), value))
elif f(value):
return g(value)
else:
return value
@staticmethod
def wrap_value(v, file: ifcopenshell.file):
def wrap(e: ifcopenshell_wrapper.entity_instance) -> entity_instance:
return entity_instance(e, file)
def is_instance(e: Any) -> bool:
return isinstance(e, ifcopenshell_wrapper.entity_instance)
return entity_instance.walk(is_instance, wrap, v)
@staticmethod
def unwrap_value(v):
def unwrap(e):
return e.wrapped_data
def is_instance(e):
return isinstance(e, entity_instance)
return entity_instance.walk(is_instance, unwrap, v)
def attribute_type(self, attr: Union[int, str]) -> str:
"""Return the data type of a positional attribute of the element
:param attr: The index or name of the attribute
"""
attr_idx = attr if isinstance(attr, numbers.Integral) else self.wrapped_data.get_argument_index(attr)
return self.wrapped_data.get_argument_type(attr_idx)
def attribute_name(self, attr_idx: int) -> str:
"""Return the name of a positional attribute of the element
:param attr_idx: The index of the attribute
"""
return self.wrapped_data.get_argument_name(attr_idx)
def __setattr__(self, key: str, value: Any) -> None:
index = self.wrapped_data.get_argument_index(key)
try:
self[index] = value
except IndexError as e:
# get_argument_index returns 0xFFFFFFFF if attribute is not found
if index == 0xFFFFFFFF:
raise AttributeError(
"entity instance of type '%s' has no attribute '%s'" % (self.wrapped_data.is_a(True), key)
)
raise e
def __getitem__(self, key: int) -> Any:
if key < 0 or key >= len(self):
raise IndexError("Attribute index {} out of range for instance of type {}".format(key, self.is_a()))
return entity_instance.wrap_value(self.wrapped_data.get_argument(key), self.wrapped_data.file)
def __setitem__(self, idx: int, value: T) -> T:
if self.wrapped_data.file and self.wrapped_data.file.transaction:
self.wrapped_data.file.transaction.store_edit(self, idx, value)
if self.method_list is None:
super().__setattr__("method_list", _method_dict[self.is_a(True)])
method = self.method_list[idx]
if value is None:
if method is not set_derived_attribute:
try:
self.wrapped_data.setArgumentAsNull(idx)
except RuntimeError as e:
if e.args == ("Attribute not set",):
raise TypeError(
"attribute '%s' is not optional for entity instance of type '%s'"
% (self.wrapped_data.get_argument_name(idx), self.wrapped_data.is_a(True))
)
raise e
else:
try:
self.method_list[idx](self.wrapped_data, idx, entity_instance.unwrap_value(value))
except TypeError:
raise TypeError(
"attribute '%s' for entity '%s' is expecting value of type '%s', got '%s'."
% (
self.wrapped_data.get_argument_name(idx),
self.wrapped_data.is_a(True),
self.wrapped_data.get_argument_type(idx),
type(value).__name__,
)
)
return value
def __len__(self):
return len(self.wrapped_data)
def __repr__(self):
return repr(self.wrapped_data)
def to_string(self, valid_spf=True) -> str:
"""Returns a string representation of the current entity instance.
Equal to str(self) when valid_spf=False. When valid_spf is True
returns a representation of the string that conforms to valid Step
Physical File notation. The difference being entity names in upper
case and string attribute values with unicode values encoded per
the specific control directives.
"""
return self.wrapped_data.to_string(valid_spf)
@overload
def is_a(self) -> str: ...
@overload
def is_a(self, ifc_class: str) -> bool: ...
@overload
def is_a(self, with_schema: bool) -> str: ...
def is_a(self, *args: Union[str, bool]) -> Union[str, bool]:
"""Return the IFC class name of an instance, or checks if an instance belongs to a class.
The check will also return true if a parent class name is provided.
:param args: If specified, is a case insensitive IFC class name to check
or if specified as a boolean then will define whether
returned IFC class name should include schema name
(e.g. "IFC4.IfcWall" if `True` and "IfcWall" if `False`).
If omitted will act as `False`.
:returns: Either the name of the class, or a boolean if it passes the check
Example:
.. code:: python
f = ifcopenshell.file()
f.create_entity('IfcPerson')
f.is_a()
>>> 'IfcPerson'
f.is_a('IfcPerson')
>>> True
"""
return self.wrapped_data.is_a(*args)
def id(self) -> int:
"""Return the STEP numerical identifier"""
return self.wrapped_data.id()
def __eq__(self, other: entity_instance) -> bool:
if not isinstance(self, type(other)):
return False
elif None in (self.wrapped_data.file, other.wrapped_data.file):
# when not added to a file, we can only compare attribute values
# and we need this for where rule evaluation
return self.get_info_2(recursive=True, include_identifier=False) == other.get_info_2(
recursive=True, include_identifier=False
)
else:
# Proper entity instances have a stable identity by means of the numeric
# step id. Selected type instances (such as IfcPropertySingleValue.NominalValue
# always have id=0, so we compare <type, value, file pointer>
if self.id():
return self.wrapped_data == other.wrapped_data
else:
return (self.is_a(), self[0], self.wrapped_data.file_pointer()) == (
other.is_a(),
other[0],
other.wrapped_data.file_pointer(),
)
def is_entity(self) -> bool:
"""Tests whether the instance is an entity type as opposed to a simple data type.
:return: True if the instance is an entity
"""
schema_name = self.wrapped_data.is_a(True).split(".")[0]
decl = ifcopenshell_wrapper.schema_by_name(schema_name).declaration_by_name(self.is_a())
return isinstance(decl, ifcopenshell_wrapper.entity)
def compare(self, other, op, reverse=False):
"""Compares with another instance.
For simple types the declaration name is not taken into account:
>>> f = ifcopenshell.file()
>>> f.createIfcInteger(0) < f.createIfcPositiveInteger(1)
True
For entity types the declaration name is taken into account:
>>> f.createIfcWall('a') < f.createIfcWall('b')
True
>>> f.createIfcWallStandardCase('a') < f.createIfcWall('b')
False
Comparing simple types with different underlying types throws an exception:
>>> f.createIfcInteger(0) < f.createIfcLabel('x')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "entity_instance.py", line 371, in compare
return op(a, b)
TypeError: '<' not supported between instances of 'int' and 'str'
:param other: Right hand side (or lhs when reverse = True)
:param op: The comparison operator (likely from the operator module)
:param reverse: When true swaps lhs and rhs. Defaults to False.
:return: bool: The comparison predicate applied to self and other
"""
if isinstance(other, entity_instance):
a, b = map(tuple, (self, other))
if any(map(entity_instance.is_entity, (self, other))):
a = (self.is_a(),) + a
b = (other.is_a(),) + b
elif self.is_entity():
a = tuple(self)
b = other
if isinstance(b, list):
b = tuple(b)
if not isinstance(b, tuple):
b = (b,)
else:
a = self[0]
b = other
if reverse:
a, b = b, a
return op(a, b)
__le__ = functools.partialmethod(compare, op=operator.le)
__lt__ = functools.partialmethod(compare, op=operator.lt)
__ge__ = functools.partialmethod(compare, op=operator.ge)
__gt__ = functools.partialmethod(compare, op=operator.gt)
__rle__ = functools.partialmethod(compare, op=operator.le, reverse=True)
__rlt__ = functools.partialmethod(compare, op=operator.lt, reverse=True)
__rge__ = functools.partialmethod(compare, op=operator.ge, reverse=True)
__rgt__ = functools.partialmethod(compare, op=operator.gt, reverse=True)
def __hash__(self):
# Proper entity instances have a stable identity by means of the numeric
# step id. Selected type instances (such as IfcPropertySingleValue.NominalValue
# always have id=0, so we hash <type, value, file pointer>
if id_ := self.id():
return hash((id_, self.wrapped_data.file_pointer()))
else:
return hash((self.is_a(), self[0], self.wrapped_data.file_pointer()))
def __dir__(self):
return sorted(
set(
itertools.chain(
dir(type(self)),
map(str, self.wrapped_data.get_attribute_names()),
map(str, self.wrapped_data.get_inverse_attribute_names()),
)
)
)
def get_info(
self,
include_identifier: bool = True,
recursive: bool = False,
return_type: Union[type[dict], type] = dict,
ignore: Sequence[str] = (),
scalar_only: bool = False,
) -> dict[str, Any]:
"""Return a dictionary of the entity_instance's properties (Python and IFC) and their values.
Resulting dictionary keys: 'id', 'type', all entity attribute names.
:param include_identifier: Whether or not to include the STEP numerical identifier
:param recursive: Whether or not to convert referenced IFC elements into dictionaries too. All attributes also apply recursively
:param return_type: The return data type to be casted into
:param ignore: A list of attribute names to ignore
:param scalar_only: Filters out all values that are IFC instances
:returns: A dictionary of properties and their corresponding values
Example:
.. code:: python
ifc_file = ifcopenshell.open(file_path)
products = ifc_file.by_type("IfcProduct")
obj_info = products[0].get_info()
print(obj_info.keys())
>>> dict_keys(['Description', 'Name', 'BuildingAddress', 'LongName', 'GlobalId', 'ObjectPlacement', 'OwnerHistory', 'ObjectType',
>>> ...'ElevationOfTerrain', 'CompositionType', 'id', 'Representation', 'type', 'ElevationOfRefHeight'])
"""
def _():
try:
if include_identifier:
yield "id", self.id()
yield "type", self.is_a()
except BaseException:
logging.exception("unhandled exception while getting id / type info on {}".format(self))
for i in range(len(self)):
try:
if self.wrapped_data.get_attribute_names()[i] in ignore:
continue
attr_value = self[i]
to_include = {"v": True}
if recursive or scalar_only:
def is_instance(e):
return isinstance(e, entity_instance)
def get_info_(inst):
return entity_instance.get_info(
inst,
include_identifier=include_identifier,
recursive=recursive,
return_type=return_type,
ignore=ignore,
)
def do_ignore(inst):
to_include["v"] = False
return None
attr_value = entity_instance.walk(
is_instance, get_info_ if recursive else do_ignore, attr_value
)
if to_include["v"]:
yield self.attribute_name(i), attr_value
except BaseException:
logging.exception("unhandled exception occurred setting attribute name for {}".format(self))
return return_type(_())
__dict__ = property(get_info)
def get_info_2(
self,
include_identifier: bool = True,
recursive: bool = False,
return_type: type[dict] = dict,
ignore: Sequence[str] = (),
) -> dict[str, Any]:
"""More perfomant version of `.get_info()` but with limited arguments values.\n
Method has exactly the same signature as `.get_info()` but it doesn't support getting information non-recursively.
Currently supported arguments values:
* recursive: `True` (will fail with default `False` value from `.get_info()`)
* return_type: `dict`
* ignore: `()` (empty tuple)
"""
assert recursive
assert return_type is dict
assert len(ignore) == 0
return ifcopenshell_wrapper.get_info_cpp(self.wrapped_data, include_identifier)