def get_symbols(self, wrapped=True):
"""Returns:
[``DB.FamilySymbol``]: List of Symbol Types in the family (unwrapped)
"""
symbols_ids = self._revit_object.GetFamilySymbolIds()
elements = [self.doc.GetElement(i) for i in symbols_ids]
return [Element(e) for e in elements] if wrapped else elements
def get_elements(self, wrapped=True):
"""
Returns list with all elements instantiated using :any:`Element`
"""
if wrapped:
return [Element(el) for el in self.__iter__()]
else:
return [element for element in self.__iter__()]
def pop(self, index=0, wrapped=True):
"""
Removed from set using ElementIds
Args:
index (``int``): Index of Element [Default: 0]
"""
element = self._elements.pop(index)
return Element(element) if wrapped else element
def instances(self):
"""Returns:
[``DB.FamilyInstance``]: List of model instances in this family (unwrapped)
"""
# There has to be a better way
instances = []
for symbol in self.symbols:
symbol_instances = Element(symbol).instances
instances.append(symbol_instances)
return instances
def get_elements(self, wrapped=True):
"""
Get other elements inside parent assembly.
Returns:
other elements inside the assembly
"""
member_ids = self._revit_object.GetMemberIds()
elements = to_elements(member_ids, doc=self._revit_object.Document)
return [Element(e) if wrapped else e for e in elements]
def apply(cls, doc, collector, func):
excluded_elements = set()
for element in collector:
wrapped_element = Element(element)
if not func(wrapped_element):
excluded_elements.add(element.Id)
excluded_elements = List[DB.ElementId](excluded_elements)
if excluded_elements:
return collector.Excluding(excluded_elements)
else:
return collector
def by_name_or_element_ref(cls, reference):
"""
Mixin for collectible elements.
This is to help cast elements from name, elemente, or element_id
"""
if isinstance(reference, str):
return cls.by_name(reference)
elif isinstance(reference, DB.ElementId):
return Element.from_id(reference)
else:
return cls(reference)
def pick_by_rectangle(self, msg):
"""
PickBox
Returns:
Elements (``List``): List of wrapped Elements
"""
# TODO: Implement ISelectFilter overload
# NOTE: This is the only method that returns elements
refs = PickElementsByRectangle(msg)
return [Element(ref) for ref in refs]
def get_assembly(self, wrapped=True):
"""
Returns:
(bool, DB.Element) ``None`` if element not in Assembly, else
returns Element
"""
if self.in_assembly:
assembly_id = self._revit_object.AssemblyInstanceId
assembly = self.doc.GetElement()
return Element(assembly) if wrapped else assembly
else:
return None
def get_first(self, wrapped=True):
"""
Returns first element or `None`
Returns:
Element (`DB.Element`, `None`): First element or None
"""
try:
element = self[0]
return Element(element) if wrapped else element
except IndexError:
return None
def families(self):
"""Returns:
[``DB.Family``]: List of Family elements in this same category (unwrapped)
"""
# There has to be a better way, but perhaps not: https://goo.gl/MqdzWg
symbols = self.symbols
unique_family_ids = set()
for symbol in symbols:
symbol_family = Element(symbol).family
unique_family_ids.add(symbol_family.Id)
return [
revit.doc.GetElement(family_id) for family_id in unique_family_ids
]
def name(self):
""" Returns:
``str``: name of the Family """
return self._revit_object.Name
# This BIP only exist in symbols, so we retrieve a symbol first.
# The Alternative is to use Element.Name.GetValue(), but I am
# avoiding it due to the import bug in ironpython
# https://github.com/IronLanguages/ironpython2/issues/79
try:
symbol = self.symbols[0]
except IndexError:
raise RpwException('Family [{}] has no symbols'.format(self.name))
return Element(
symbol).parameters.builtins['SYMBOL_FAMILY_NAME_PARAM'].value
def get_first(self, wrapped=True):
""" Get First Item in Collection
Args:
wrapped (bool): True for wrapped. Default is True.
Returns:
(db.Element, DB.Element): First Element, or None if empty.
"""
try:
element = self._elements[0]
except IndexError:
return None
else:
return Element(element) if wrapped else element
def get_families(self, wrapped=True, doc=None):
"""
Returns:
Families (``DB.Family``): List of Family elements in this
same category
"""
# There has to be a better way, but perhaps not: https://goo.gl/MqdzWg
unique_family_ids = set()
for symbol in self.get_symbols(wrapped=True):
unique_family_ids.add(symbol.family.Id)
doc = doc or revit.doc
elements = [
doc.GetElement(family_id) for family_id in unique_family_ids
]
return [Element(e) for e in elements] if wrapped else elements
def __iter__(self):
""" Iterator: Wrapped """
for element in self._element_id_set:
yield Element.from_id(element)
def elements(self):
member_ids = self._revit_object.GetMemberIds()
elements = to_elements(member_ids, doc=self._revit_object.Document)
return [Element(e) for e in elements]
def _wrapped_elements(self):
return Element.from_list(self._element_id_set)
def wrapped_elements(self):
""" Returns list with all elements instantiated using :any:`Element` """
return [Element(el) for el in self.__iter__()]
def wrapped_elements(self):
"""
Returns:
List of wrapped elements stored in ElementSet
"""
return [Element(x) for x in self.elements]
def __repr__(self):
return Element.__repr__(self, data={'name': self.name})
def siblings(self):
""" Returns all assembly types """
return [Element.from_id(t) for t in self._revit_object.GetSimilarTypes()]
def get_element(self, wrapped=True):
""" Element of Reference """
element = self.doc.GetElement(self.id)
return element if not wrapped else Element(element)
