def coerce_param_reference(self, parameter_reference):
if isinstance(parameter_reference, str):
param_id = BipEnum.get_id(parameter_reference)
elif isinstance(parameter_reference, DB.ElementId):
param_id = parameter_reference
else:
RpwCoerceError(parameter_reference, ElementId)
return param_id
def process_value(cls, level_reference):
""" Process level= input to allow for level name """
if isinstance(level_reference, str):
level = Collector(of_class='Level', is_type=False,
where=lambda x:
x.Name == level_reference)
try:
level_id = level[0].Id
except IndexError:
RpwCoerceError(level_reference, DB.Level)
else:
level_id = to_element_id(level_reference)
return DB.ElementLevelFilter(level_id, cls.reverse)
def get(self, category_name):
""" Gets Built In Category by Name
Args:
``str``: Name of Category
Returns:
``DB.BuiltInCategory``: BuiltInCategory Enumeration Member
"""
try:
enum = getattr(DB.BuiltInCategory, category_name)
except AttributeError:
raise RpwCoerceError(category_name, DB.BuiltInCategory)
return enum
def get(self, parameter_name):
""" Gets Built In Parameter by Name
Args:
``str``: Name of Parameter
Returns:
``DB.BuiltInParameter``: BuiltInParameter Enumeration Member
"""
try:
enum = getattr(DB.BuiltInParameter, parameter_name)
except AttributeError:
raise RpwCoerceError(parameter_name, DB.BuiltInParameter)
return enum
def from_category_id(self, category_id):
"""
Casts ``DB.BuiltInCategory`` Enumeration member from a Category ElementId
Args:
category_id (``DB.ElementId``): ElementId reference of a category
Returns:
``DB.BuiltInCategory`` member
"""
bic = Enum.ToObject(DB.BuiltInCategory, category_id.IntegerValue)
if DB.ElementId(bic).IntegerValue < -1:
return bic
else:
# If you pass a regular element to category_id, it converts it to BIC.
# It should fail, because result is not a valid Category Enum
raise RpwCoerceError('category_id: {}'.format(category_id),
DB.BuiltInCategory)
def __init__(self, *xyz_or_tuple):
"""
Args:
instance (``DB.XYZ``): Instance of XYZ to be wrapped
"""
if len(xyz_or_tuple) == 3:
xyz = DB.XYZ(*xyz_or_tuple)
elif len(xyz_or_tuple) == 2:
xyz = DB.XYZ(xyz_or_tuple[0], xyz_or_tuple[1], 0)
elif len(xyz_or_tuple) == 1 and isinstance(xyz_or_tuple[0], (tuple, list)):
# Assumes one arg, tuple
xyz = DB.XYZ(*xyz_or_tuple[0])
elif isinstance(xyz_or_tuple, (list, tuple)):
# Assumes one arg, DB.XYZ
xyz = xyz_or_tuple[0]
else:
raise RpwCoerceError(xyz_or_tuple, 'point-like object')
super(XYZ, self).__init__(xyz)
def by_name(cls, name):
"""
Mixin to provide instantiating by a name for classes that are collectible.
This is a mixin so specifi usage will vary for each for.
This method will call the :any:`collect` method of the class,
and return the first element with a matching ``Name`` property.
See implementation for more details.
>>> LinePatternElement.by_name('Dash')
<rpw:LinePatternElement name:Dash>
>>> FillPatternElement.by_name('Solid')
<rpw:FillPatternElement name:Solid>
"""
first = cls.collect(where=lambda e: e.Name == name).first
if first:
return cls(first)
else:
raise RpwCoerceError('by_name({})'.format(name), cls)
def by_name(cls, name):
"""
Mixin to provide instantiating by a name for classes that are
collectible. This is a mixin so specifi usage will vary for each for.
This method will call the :any:`rpw.db.Element.collect`
method of the class, and return the first element with a
matching ``.name`` property.
>>> LinePatternElement.by_name('Dash')
<rpw:LinePatternElement name:Dash>
>>> FillPatternElement.by_name('Solid')
<rpw:FillPatternElement name:Solid>
"""
e = cls.collect(
where=lambda e: e.name.lower() == name.lower()).get_first()
if e:
return e
raise RpwCoerceError('by_name({})'.format(name), cls)
def __init__(self, *point_reference):
"""
XYZ Supports a wide variety of instantiation overloads:
>>> XYZ(0,0)
>>> XYZ(0,0,0)
>>> XYZ([0,0])
>>> XYZ([0,0,0])
>>> XYZ(DB.XYZ(0,0,0))
Args:
point_reference (``DB.XYZ``,``iterable``, ``args``): Point like data
"""
# XYZ(0,0,0)
if len(point_reference) == 3:
xyz = DB.XYZ(*point_reference)
# XYZ(0,0)
elif len(point_reference) == 2:
xyz = DB.XYZ(point_reference[0], point_reference[1], 0)
# XYZ([0,0,0]) or # XYZ([0,0])
elif len(point_reference) == 1 and isinstance(point_reference[0],
(tuple, list)):
# Assumes one arg, tuple
xyz = XYZ(*point_reference[0])
xyz = DB.XYZ(*xyz.as_tuple)
# XYZ(DB.XYZ(0,0,0))
elif len(point_reference) == 1 and isinstance(point_reference[0],
DB.XYZ):
# Assumes one arg, DB.XYZ
xyz = point_reference[0]
elif len(point_reference) == 1 and isinstance(point_reference[0], XYZ):
# Assumes one arg, DB.XYZ
xyz = point_reference[0].unwrap()
else:
raise RpwCoerceError(point_reference, 'point-like object')
super(XYZ, self).__init__(xyz)