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))
