def to_category(category_reference, fuzzy=True):
""" Coerces a category, category name or category id to a BuiltInCategory.
>>> from rpw.utils.coerce import to_category
>>> to_category('OST_Walls')
BuiltInCategory.OST_Walls
>>> to_category('Walls')
BuiltInCategory.OST_Walls
>>> to_category(BuiltInCategory.OST_Walls)
BuiltInCategory.OST_Walls
Args:
cateagory_reference ([``DB.BuiltInCategory``, ``str``, ``CategoryId``]): Category Reference
or Name
Returns:
[``BuiltInCategory``]: BuiltInCategory
"""
if isinstance(category_reference, DB.BuiltInCategory):
return category_reference
if isinstance(category_reference, str):
if fuzzy:
return BicEnum.fuzzy_get(category_reference)
else:
return BicEnum.get(category_reference)
if isinstance(category_reference, DB.ElementId):
return BicEnum.from_category_id(category_reference)
raise RpwTypeError('Category Type, Category Type Name',
type(category_reference))
def __new__(cls, element, **kwargs):
"""
Factory Constructor will chose the best Class for the Element.
This function iterates through all classes in the rpw.db module,
and will find one that wraps the corresponding class. If and exact
match is not found :any:`Element` is used
"""
defined_wrapper_classes = rpw.db.__all__
_revit_object_class = cls._revit_object_class
if element is None:
raise RpwTypeError('Element or Element Child', 'None')
# TODO: Handle double wrapping
if hasattr(element, 'unwrap'):
raise RpwTypeError('revit element', 'wrapped element: {}'.format(element))
# Ensure Wrapped Element is instance of Class Wrapper or decendent
if not isinstance(element, _revit_object_class):
raise RpwTypeError(_revit_object_class.__name__,
element.__class__.__name__)
# Ensure Wrapped Element is instance of Class Wrapper or decendent
if not isinstance(element, _revit_object_class):
raise RpwTypeError(_revit_object_class, element.__class__)
# If explicit constructor was called, use that and skip discovery
if type(element) is _revit_object_class:
return super(Element, cls).__new__(cls, element, **kwargs)
for wrapper_class in defined_wrapper_classes:
class_name = wrapper_class.__name__
if type(element) is getattr(wrapper_class, '_revit_object_class', None):
# Found Mathing Class, Use Wrapper
# print('Found Mathing Class, Use Wrapper: {}'.format(class_name))
return super(Element, cls).__new__(wrapper_class, element, **kwargs)
else:
# Could Not find a Matching Class, Use Element if related
return super(Element, cls).__new__(cls, element, **kwargs)
# No early return. Should not reach this point
element_class_name = element.__class__.__name__
raise RpwException('Factory does not support type: {}'.format(element_class_name))
def __init__(self, parameter):
""" Parameter Wrapper Constructor
Args:
DB.Parameter: Parameter to be wrapped
Returns:
Parameter: Wrapped Parameter Class
"""
if not isinstance(parameter, DB.Parameter):
raise RpwTypeError(DB.Parameter, type(parameter))
super(Parameter, self).__init__(parameter)
def to_element(element_reference, doc=revit.doc):
if isinstance(element_reference, DB.ElementId):
element = doc.GetElement(element_reference)
elif isinstance(element_reference, DB.Reference):
element = doc.GetElement(element_reference)
elif isinstance(element_reference, int):
element = doc.GetElement(DB.ElementId(element_reference))
elif isinstance(element_reference, DB.Element):
element = element_reference
else:
raise RpwTypeError('Element, ElementId, or int', type(element_reference))
return element
def __new__(cls, element, **kwargs):
"""
Factory Constructor will chose the best Class for the Element.
This function iterates through all classes in the rpw.db module,
and will find one that wraps the corresponding class. If and exact
match is not found :any:`Element` is used
"""
defined_wrapper_classes = inspect.getmembers(rpw.db, inspect.isclass)
# [('Area', '<class Area>'), ... ]
_revit_object_class = cls._revit_object_class
if element is None:
raise RpwTypeError('Element or Element Child', 'None')
# Ensure Wrapped Element is instance of Class Wrapper or decendent
# Must also check is element because isinstance(Element, Element) is False
if not isinstance(element, _revit_object_class):
# or cls is not Element:
raise RpwTypeError(_revit_object_class, type(element))
# rpw.ui.forms.Console()
for class_name, wrapper_class in defined_wrapper_classes:
if type(element) is getattr(wrapper_class, '_revit_object_class',
None):
# Found Mathing Class, Use Wrapper
# print('Found Mathing Class, Use Wrapper: {}'.format(class_name))
return super(Element, cls).__new__(wrapper_class, element,
**kwargs)
# new_obj._revit_object = element
# return new_object
else:
# Could Not find a Matching Class, Use Element if related
# print('Did not find a Matching Class, will use Element if related')
if DB.Element in inspect.getmro(element.__class__):
return super(Element, cls).__new__(cls, element, **kwargs)
element_class_name = element.__class__.__name__
raise RpwException(
'Factory does not support type: {}'.format(element_class_name))
def __new__(cls, element, **kwargs):
"""
Factory Constructor will chose the best Class for the Element.
This function iterates through all classes in the rpw.db module,
and will find one that wraps the corresponding class. If and exact
match is not found :any:`Element` is used
"""
defined_wrapper_classes = rpw.db.__all__
_revit_object_class = cls._revit_object_class
if element is None:
raise RpwTypeError('Element or Element Child', 'None')
# Ensure Wrapped Element is instance of Class Wrapper or decendent
# Must also check is element because isinstance(Element, Element) is False
if not isinstance(element, _revit_object_class):
# or cls is not Element:
raise RpwTypeError('DB.Element child', element.__class__.__name__)
# TODO: OPtimize so if its right type, no need to iterate: rpw.db.Wall(wall)
for wrapper_class in defined_wrapper_classes:
class_name = wrapper_class.__name__
if type(element) is getattr(wrapper_class, '_revit_object_class',
None):
# Found Mathing Class, Use Wrapper
# print('Found Mathing Class, Use Wrapper: {}'.format(class_name))
return super(Element, cls).__new__(wrapper_class, element,
**kwargs)
else:
# Could Not find a Matching Class, Use Element if related
if DB.Element in inspect.getmro(element.__class__):
return super(Element, cls).__new__(cls, element, **kwargs)
# No early return. Should not reach this point
element_class_name = element.__class__.__name__
raise RpwException(
'Factory does not support type: {}'.format(element_class_name))
def to_element_id(element_reference):
if hasattr(element_reference, 'Id'):
element_id = element_reference.Id
elif isinstance(element_reference, DB.Reference):
element_id = element_reference.ElementId
elif isinstance(element_reference, int):
element_id = DB.ElementId(element_reference)
elif isinstance(element_reference, DB.ElementId):
element_id = element_reference
elif element_reference == DB.ElementId.InvalidElementId:
element_id = element_reference
else:
raise RpwTypeError('Element, ElementId, or int', type(element_reference))
return element_id
def __init__(self, revit_object, enforce_type=True):
"""
Child classes can use self._revit_object to refer back to Revit Element
Warning:
Any Wrapper that inherits and overrides __init__ class MUST
super to ensure _revit_object is created by calling super().__init__
BaseObjectWrapper must define a class variable _revit_object_class
to define the object being wrapped.
"""
_revit_object_class = self.__class__._revit_object_class
if enforce_type and not isinstance(revit_object, _revit_object_class):
raise RpwTypeError(_revit_object_class, type(revit_object))
object.__setattr__(self, '_revit_object', revit_object)
def to_element(element_reference, doc=revit.doc):
""" Same as to_elements but for a single object """
if isinstance(element_reference, DB.Element):
element = element_reference
elif isinstance(element_reference, DB.ElementId):
element = doc.GetElement(element_reference)
elif isinstance(element_reference, DB.Reference):
element = doc.GetElement(element_reference)
elif isinstance(element_reference, int):
element = doc.GetElement(DB.ElementId(element_reference))
elif hasattr(element_reference, 'unwrap'):
element = element_reference.unwrap()
else:
raise RpwTypeError('Element, ElementId, or int',
type(element_reference))
return element
def to_class(class_reference):
""" Coerces a class or class reference to a Class.
>>> from rpw.utils.coerce import to_class
>>> to_class('Wall')
[ DB.Wall ]
>>> to_class(Wall)
[ DB.Wall ]
Args:
class_reference ([``DB.Wall``, ``str``]): Class Reference or class name
Returns:
[``type``]: Class
"""
if isinstance(class_reference, str):
return getattr(DB, class_reference)
if isinstance(class_reference, type):
return class_reference
raise RpwTypeError('Class Type, Class Type Name', type(class_reference))
def to_element_id(element_reference):
"""
Coerces Element References (Element, ElementId, ...) to Element Id
>>> from rpw.utils.coerce import to_element_id
>>> to_element_id(SomeElement)
<Element Id>
"""
if hasattr(element_reference, 'Id'):
element_id = element_reference.Id
elif isinstance(element_reference, DB.Reference):
element_id = element_reference.ElementId
elif isinstance(element_reference, int):
element_id = DB.ElementId(element_reference)
elif isinstance(element_reference, DB.ElementId):
element_id = element_reference
elif element_reference == DB.ElementId.InvalidElementId:
element_id = element_reference
else:
raise RpwTypeError('Element, ElementId, or int',
type(element_reference))
return element_id
