def get_links(linktype=None, doc=None): doc = doc or HOST_APP.doc location = doc.PathName if not location: raise PyRevitException('PathName is empty. Model is not saved.') links = [] model_path = \ DB.ModelPathUtils.ConvertUserVisiblePathToModelPath(location) if not model_path: raise PyRevitException('Model is not saved. Can not read links.') try: trans_data = DB.TransmissionData.ReadTransmissionData(model_path) external_refs = trans_data.GetAllExternalFileReferenceIds() for ref_id in external_refs: ext_ref = trans_data.GetLastSavedReferenceData(ref_id) link = doc.GetElement(ref_id) if linktype: if ext_ref.ExternalFileReferenceType == linktype: links.append(db.ExternalRef(link, ext_ref)) else: links.append(db.ExternalRef(link, ext_ref)) return links except Exception as data_err: raise PyRevitException( 'Error reading links from model path: {} | {}'.format( model_path, data_err))
def rename_tag(tag, new_tag_name, elements=None): """Rename a tag id in model or on a set of elements. Args: tag (Tag): tag to be renamed new_tag_name (str): new tag identifier elements (list[DB.Element], optional): set of elements to rename the tag. Raises: PyRevitException: invalid tag name Examples: >>> import tagsmgr >>> tagmgr.rename_tag(tag, 'NEW_SCOPE') >>> tagmgr.rename_tag(tag, 'NEW_SCOPEA,SCOPEB') Traceback (most recent call last): File "<stdin>", line 1, in <module> PyRevitException: Invalid Tag Name """ newtag = Tag(new_tag_name) if newtag.is_valid(): if is_tag_available(newtag): raise PyRevitException('New tag name already exists.') target_elements = elements or get_all_tag_elements(tag) for element in target_elements: el_tags = list(extract_tags(element)) extag_idx = el_tags.index(tag) el_tags[extag_idx].rename(new_tag_name) apply_tags(element, el_tags) else: raise PyRevitException('Invalid Tag Name')
def paste(self): # load data vzps_data = script.load_data(slot_name=self.__class__.__name__, this_project=False) view_type = vzps_data.view_type vc1, vc2 = vzps_data.corner_pts dir_orient = vzps_data.dir_orient active_ui_view = revit.uidoc.GetOpenUIViews()[0] if not self.is_compatible_viewtype(revit.active_view, view_type): raise PyRevitException( 'Saved view type (%s) is different from active view (%s)' % (vzps_data.view_type, type(revit.active_view).ViewType)) # load ViewOrientation3D if isinstance(revit.active_view, DB.View3D): if revit.active_view.IsLocked: raise PyRevitException('Current view orientation is locked') revit.active_view.SetOrientation(dir_orient) elif isinstance(revit.active_view, DB.ViewSection): angle = dir_orient.AngleTo(revit.active_view.ViewDirection) if not pyutils.almost_equal(angle, math.pi) \ and not pyutils.almost_equal(angle, 0): raise PyRevitException("Views are not parallel") active_ui_view.ZoomAndCenterRectangle(vc1, vc2)
def create_shared_param( param_id_or_name, category_list, builtin_param_group, type_param=False, allow_vary_betwen_groups=False, #pylint: disable=W0613 doc=None): doc = doc or HOST_APP.doc msp_list = query.get_defined_sharedparams() param_def = None for msp in msp_list: if msp == param_id_or_name: param_def = msp.param_def if not param_def: raise PyRevitException('Can not find shared parameter.') if category_list: category_set = query.get_category_set(category_list, doc=doc) else: category_set = query.get_all_category_set(doc=doc) if not category_set: raise PyRevitException('Can not create category set.') if type_param: new_binding = \ HOST_APP.app.Create.NewTypeBinding(category_set) else: new_binding = \ HOST_APP.app.Create.NewInstanceBinding(category_set) doc.ParameterBindings.Insert(param_def, new_binding, builtin_param_group) return True
def copy(self): views = revit.get_selection().only_views() if views: view = views[0] view_filters = revit.query.get_view_filters(view) if not view_filters: raise PyRevitException('Active view has no fitlers applied') selected_filters = forms.SelectFromList.show( view_filters, name_attr='Name', title='Select filters to copy', button_name='Select filters', multiselect=True ) if not selected_filters: raise PyRevitException('No filters selected. Cancelled.') script.store_data( slot_name=self.__class__.__name__, data=FilterOverridesData( source_viewid=view.Id, filter_ids=[f.Id for f in view_filters] ) )
def create_shared_param(param_id_or_name, category_list, builtin_param_group, type_param=False, doc=None): doc = doc or HOST_APP.doc msp_list = query.get_sharedparam_definition_file() for msp in msp_list: if msp == param_id_or_name: param_def = msp.param_def if not param_def: raise PyRevitException('Can not find shared parameter.') category_set = create_category_set(category_list, doc=doc) if not category_set: raise PyRevitException('Can not create category set.') if type_param: new_binding = \ HOST_APP.app.Create.NewTypeBinding(category_set) else: new_binding = \ HOST_APP.app.Create.NewInstanceBinding(category_set) doc.ParameterBindings.Insert(param_def, new_binding, builtin_param_group) return True
def get_sharedparam_definition_file(): if HOST_APP.app.SharedParametersFilename: sparamf = HOST_APP.app.OpenSharedParameterFile() if sparamf: return sparamf else: raise PyRevitException('Failed opening Shared Parameters file.') else: raise PyRevitException('No Shared Parameters file defined.')
def _check_dependencies(self): if self.min_revit_ver: # If host is older than the minimum host version, raise exception if int(HOST_APP.version) < int(self.min_revit_ver): raise PyRevitException('Script requires min host version: {}'.format(self.min_revit_ver)) if self.max_revit_ver: # If host is newer than the max host version, raise exception if int(HOST_APP.version) > int(self.max_revit_ver): raise PyRevitException('Script requires max host version: {}'.format(self.max_revit_ver))
def _get_item(adc, path): path = _ensure_local_path(adc, path) if not op.isfile(path): raise PyRevitException("Path does not point to a file") res = adc.GetItemsByWorkspacePaths([path]) if not res: raise PyRevitException("Can not find item in any ADC drive") # grab the first item (we only except one since path is to a file) return res[0].Item
def create_shared_param(param_id_or_name, category_list, builtin_param_group, type_param=False, allow_vary_betwen_groups=False, doc=None): doc = doc or DOCS.doc # get define shared parameters # this is where we grab the ExternalDefinition for the parameter msp_list = query.get_defined_sharedparams() param_def = None for msp in msp_list: if msp == param_id_or_name: param_def = msp.param_def if not param_def: raise PyRevitException('Can not find shared parameter.') # now create the binding for this definition return create_param_from_definition( param_def, category_list, builtin_param_group=builtin_param_group, type_param=type_param, allow_vary_betwen_groups=allow_vary_betwen_groups, doc=doc)
def create_param_from_definition( param_def, category_list, builtin_param_group, type_param=False, allow_vary_betwen_groups=False, #pylint: disable=unused-argument doc=None): doc = doc or DOCS.doc # verify and create category set if category_list: category_set = query.get_category_set(category_list, doc=doc) else: category_set = query.get_all_category_set(doc=doc) if not category_set: raise PyRevitException('Can not create category set.') # create binding if type_param: new_binding = \ HOST_APP.app.Create.NewTypeBinding(category_set) else: new_binding = \ HOST_APP.app.Create.NewInstanceBinding(category_set) # FIXME: set allow_vary_betwen_groups # param_def.SetAllowVaryBetweenGroups(doc, allow_vary_betwen_groups) # insert the binding doc.ParameterBindings.Insert(param_def, new_binding, builtin_param_group) return True
def _make_csharp_types(module_builder, cmd_component): compiled_assm = _get_csharp_cmd_asm(cmd_component) iext_cmd, iext_cmd_avail = _verify_command_interfaces(compiled_assm) if iext_cmd: create_type(module_builder, iext_cmd, cmd_component.unique_name, create_ext_command_attrs()) cmd_component.class_name = cmd_component.unique_name else: raise PyRevitException('Can not find IExternalCommand derivatives ' 'for: {}'.format(cmd_component)) if iext_cmd_avail: create_type(module_builder, iext_cmd_avail, cmd_component.unique_avail_name, []) cmd_component.avail_class_name = cmd_component.unique_avail_name else: logger.debug('Can not find IExternalCommandAvailability derivatives ' 'for: {}'.format(cmd_component))
def extract_param(self, param_name, default_value=None): """Find variable and extract its value. Args: param_name (str): variable name default_value (any): default value to be returned if variable does not exist Returns: any: value of the variable or :obj:`None` """ try: for child in ast.iter_child_nodes(self.ast_tree): if hasattr(child, 'targets'): for target in child.targets: if hasattr(target, 'id') and target.id == param_name: param_value = ast.literal_eval(child.value) if isinstance(param_value, str): param_value = param_value.decode('utf-8') return param_value except Exception as err: raise PyRevitException('Error parsing parameter: {} ' 'in script file for : {} | {}'.format( param_name, self.file_addr, err)) return default_value
def _parse_or_cache(ext_info): try: # raise error if ui_extension does not have a valid cache if not is_cache_valid(ext_info): raise PyRevitException( 'Cache is not valid for: {}'.format(ext_info)) # if cache is valid, load the cached ui_extension logger.debug('Cache is valid for: {}'.format(ext_info)) # cacher module takes the ui_extension object and injects cache data into it. ui_extension = get_cached_extension(ext_info) logger.info('UI Extension successfuly loaded from cache: {}'.format( ui_extension.name)) except PyRevitException as cache_err: logger.debug(cache_err) # Either cache is not available, not valid, or cache load has failed. # parse directory for components and return fully loaded ui_extension logger.debug('Parsing for ui_extension...') ui_extension = get_parsed_extension(ext_info) # update cache with newly parsed ui_extension logger.info('UI Extension successfuly parsed: {}'.format( ui_extension.name)) logger.info('Updating cache for ui_extension: {}'.format( ui_extension.name)) update_cache(ui_extension) return ui_extension
def compile_csharp(sourcefiles_list, full_output_file_addr=None, reference_list=None, resource_list=None): """Compile list of c-sharp source files to assembly. if full_output_file_addr is provided, the generated dll will be written to that file, otherwise the assembly will be generated in memory. Args: sourcefiles_list (list[str]): list of source c-sharp files full_output_file_addr (str): full path of output dll reference_list (list[str]): list of reference assemblies resource_list (list[str]): list of resources to be included Returns: str or System.Reflection.Assembly: path to assembly if dll path provided, otherwise generated assembly """ mlogger.debug('Getting csharp provider.') cleanedup_source_list = \ [src.replace('\\', '\\\\') for src in sourcefiles_list] provider = \ CSharpCodeProvider(Dictionary[str, str]({'CompilerVersion': 'v4.0'})) if not provider: raise PyRevitException("Compile error: Can not get C# Code Provider.") return _compile_dotnet(provider, cleanedup_source_list, full_output_file_addr, reference_list, resource_list)
def read_source_file(source_file_path): try: with open(source_file_path, 'r') as code_file: return code_file.read() except Exception as read_err: raise PyRevitException('Error reading source file: {} | {}'.format( source_file_path, read_err))
def __init__(self, file_address): self.file_addr = file_address try: with open(file_address, 'r') as f: self.ast_tree = ast.parse(f.read()) except Exception as err: raise PyRevitException('Error parsing script file: {} | {}'.format(self.file_addr, err))
def __init__(self, start_u, start_v, end_u, end_v, model_pattern, expandable): self._origin = _PatternPoint(min(start_u, end_u), min(start_v, end_v)) self._corner = _PatternPoint(max(start_u, end_u), max(start_v, end_v)) self._bounds = self._corner - self._origin self._normalized_domain = \ _PatternPoint(1.0, 1.0 * (self._bounds.v / self._bounds.u)) if self._zero_domain(): raise PyRevitException('Can not process zero domain.') self.u_vec = _PatternLine(_PatternPoint(0, 0), _PatternPoint(self._bounds.u, 0)) self.v_vec = _PatternLine(_PatternPoint(0, 0), _PatternPoint(0, self._bounds.v)) if model_pattern: self._max_domain = MAX_MODEL_DOMAIN else: self._max_domain = MAX_DETAIL_DOMAIN self._expandable = expandable self._target_domain = self._max_domain self.diagonal = _PatternLine(_PatternPoint(0.0, 0.0), _PatternPoint(self._bounds.u, self._bounds.v)) self._calculate_safe_angles()
def find_type_by_name(assembly, type_name): base_class = assembly.GetType(type_name) if base_class is not None: return base_class else: raise PyRevitException( 'Can not find base class type: {}'.format(type_name))
def _ensure_local_path(adc, path): drv_info = _get_drive_from_path(adc, path) if drv_info: return _drive_path_to_local_path(drv_info, path) elif not _get_drive_from_local_path(adc, path): raise PyRevitException("Path is not inside any ADC drive") return path
def get_family_parameter(param_name, family_doc): if family_doc.IsFamilyDocument: for fparam in family_doc.FamilyManager.GetParameters(): if fparam.Definition.Name == param_name: return fparam else: raise PyRevitException('Document is not a family')
def get_family_type(type_name, family_doc): if family_doc.IsFamilyDocument: for ftype in family_doc.FamilyManager.Types: if ftype.Name == type_name: return ftype else: raise PyRevitException('Document is not a family')
def _generate_runtime_asm(): source_list = [] for source_file in _get_source_files(): source_list.append(source_file) # now try to compile try: mlogger.debug('Compiling base types to: %s', RUNTIME_ASSM_FILE) res, msgs = labs.Common.CodeCompiler.CompileCSharp( sourceFiles=Array[str](source_list), outputPath=RUNTIME_ASSM_FILE, references=Array[str](get_references()), defines=Array[str](["REVIT{}".format(HOST_APP.version)])) # log results logfile = RUNTIME_ASSM_FILE.replace('.dll', '.log') with open(logfile, 'w') as lf: lf.write('\n'.join(msgs)) # load compiled dll if successful if res: return assmutils.load_asm_file(RUNTIME_ASSM_FILE) # otherwise raise hell else: raise PyRevitException("Error compiling runtime") except PyRevitException as compile_err: errors = safe_strtype(compile_err).replace('Compile error: ', '') mlogger.critical('Can not compile base types code into assembly.\n%s', errors) raise compile_err
def __setattr__(self, param_name, value): if param_name in ['_parser', '_section_name']: super(PyRevitConfigSectionParser, self).__setattr__(param_name, value) else: try: return self._parser.set(self._section_name, param_name, unicode(value)) except Exception as set_err: raise PyRevitException('Error setting parameter value. | {}'.format(set_err))
def __init__(self, info_dict, def_file_path=None): """ Initialized the extension class based on provide information (info_dict) Required info (Dictionary keys): type, name, description , url Optional info: website, image, author, author-url Args: info_dict (dict): A dictionary containing the required information for initializing the extension. def_file_path (str): The file path of the extension definition file """ # Setting required attributes try: ext_type = info_dict['type'] if ext_type == ExtensionTypes.UI_EXTENSION.ID: self.type = ExtensionTypes.UI_EXTENSION elif ext_type == ExtensionTypes.LIB_EXTENSION.ID: self.type = ExtensionTypes.LIB_EXTENSION self.builtin = info_dict['builtin'].lower() == 'true' self.enable_default = info_dict['enable'].lower() == 'true' self.name = info_dict['name'] self.description = info_dict['description'] self.url = info_dict['url'] self.def_file_path = def_file_path except KeyError as ext_info_err: raise PyRevitException('Required plugin ext info not available. ' '| {}'.format(ext_info_err)) # Setup access if 'authusers' in info_dict: self.authusers = info_dict['authusers'] else: self.authusers = None # Setting extended attributes try: self.website = info_dict['website'] self.image = info_dict['image'] self.author = info_dict['author'] self.author_profile = info_dict['author-url'] self.dependencies = info_dict['dependencies'] except Exception as ext_info_err: self.website = self.url.replace('.git', '') self.image = None self.author = self.author_profile = None self.dependencies = [] logger.debug( 'Missing extended plugin ext info. | {}'.format(ext_info_err))
def update_cache(parsed_ext): try: mlogger.debug('Writing cache for: %s', parsed_ext) cache_file = _get_cache_file(parsed_ext) mlogger.debug('Cache file is: %s', cache_file) with open(cache_file, 'wb') as bin_cache_file: pickle.dump(parsed_ext, bin_cache_file, pickle.HIGHEST_PROTOCOL) except Exception as err: raise PyRevitException('Error writing cache for: {} | {}'.format( parsed_ext, err))
def pick_element_by_category(cat_name_or_builtin, message=''): category = query.get_category(cat_name_or_builtin) if category: pick_filter = PickByCategorySelectionFilter(category.Id) return _pick_obj(UI.Selection.ObjectType.Element, message, selection_filter=pick_filter) else: raise PyRevitException("Can not determine category id from: {}".format( cat_name_or_builtin))
def __init__(self, cfg_file_path=None): self._parser = ConfigParser.ConfigParser() if cfg_file_path is not None: try: with open(cfg_file_path, 'r') as cfg_file: self._parser.readfp(cfg_file) except (OSError, IOError): raise PyRevitIOError() except Exception as read_err: raise PyRevitException(read_err)
def enable_worksharing(levels_workset_name='Shared Levels and Grids', default_workset_name='Workset1', doc=None): doc = doc or DOCS.doc if not doc.IsWorkshared: if doc.CanEnableWorksharing: doc.EnableWorksharing(levels_workset_name, default_workset_name) else: raise PyRevitException('Worksharing can not be enabled. ' '(CanEnableWorksharing is False)')
def _write_cache_for(parsed_ext): try: mlogger.debug('Writing cache for: %s', parsed_ext) cache_file = _get_cache_file(parsed_ext) mlogger.debug('Cache file is: %s', cache_file) with open(cache_file, 'w') as cache_file: cache_file.write(_make_cache_from_cmp(parsed_ext)) except Exception as err: raise PyRevitException('Error writing cache for: {} | {}'.format( parsed_ext, err))