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)