def __getattr__(self, attr):
logger.debug("Getting Atts:{} from {}')".format(attr, self.fullname))
path_and_attr = '.'.join([self.fullname, attr])
# print(path_and_attr)
if path_and_attr in MockObject.MOCK_OVERRIDE:
return MockObject.MOCK_OVERRIDE[path_and_attr]
return MockObject(fullname=attr)
def __getattr__(self, attr):
logger.debug("Getting Atts:{} from {}')".format(attr, self.fullname))
path_and_attr = '.'.join([self.fullname, attr])
# print(path_and_attr)
if path_and_attr in MockObject.MOCK_OVERRIDE:
return MockObject.MOCK_OVERRIDE[path_and_attr]
return MockObject(fullname=attr)
def _set_overrides(self, target):
targets = to_iterable(target)
for target in targets:
try:
category_id = to_category_id(target)
self._set_category_overrides(category_id)
except (RpwTypeError, RpwCoerceError) as errmsg:
logger.debug('Not Category, Trying Element Override')
element_id = to_element_id(target)
self._set_element_overrides(element_id)
def _pick(cls, obj_type, msg='Pick:', multiple=False, linked=False):
""" Note: Moved Reference Logic to Referenc Wrapper."""
try:
if multiple:
references = PickObjects(obj_type, msg)
else:
reference = PickObject(obj_type, msg)
except RevitExceptions.OperationCanceledException:
logger.debug('ui.Pick aborted by user')
sys.exit(0)
if multiple:
return [Reference(ref, linked=linked) for ref in references]
else:
return Reference(reference, linked=linked)
def load_module(self, fullname):
"""This method is called by Python if CustomImporter.find_module
does not return None. fullname is the fully-qualified name
of the module/package that was requested."""
if fullname in sys.modules:
return sys.modules[fullname]
else:
logger.debug('Importing Mock Module: {}'.format(fullname))
# mod = imp.new_module(fullname)
# import pdb; pdb.set_trace()
mod = MockObject(fullname=fullname)
mod.__loader__ = self
mod.__file__ = fullname
mod.__path__ = [fullname]
mod.__name__ = fullname
sys.modules[fullname] = mod
return mod # This gives errors
def load_module(self, fullname):
"""This method is called by Python if CustomImporter.find_module
does not return None. fullname is the fully-qualified name
of the module/package that was requested."""
if fullname in sys.modules:
return sys.modules[fullname]
else:
logger.debug('Importing Mock Module: {}'.format(fullname))
# mod = imp.new_module(fullname)
# import pdb; pdb.set_trace()
mod = MockObject(fullname=fullname)
mod.__loader__ = self
mod.__file__ = fullname
mod.__path__ = [fullname]
mod.__name__ = fullname
sys.modules[fullname] = mod
return mod # This gives errors
def _collect(self, doc, collector, filters):
"""
Main Internal Recursive Collector Function.
Args:
doc (`UI.UIDocument`): Document for the collector.
collector (`FilteredElementCollector`): FilteredElementCollector
filters (`dict`): Filters - {'doc': revit.doc, 'of_class': 'Wall'}
Returns:
collector (`FilteredElementCollector`): FilteredElementCollector
"""
for filter_class in FilterClasses.get_sorted():
if filter_class.keyword not in filters:
continue
filter_value = filters.pop(filter_class.keyword)
logger.debug('Applying Filter: {}:{}'.format(filter_class, filter_value))
new_collector = filter_class.apply(doc, collector, filter_value)
return self._collect(doc, new_collector, filters)
return collector
def _collect(self, doc, collector, filters):
"""
Main Internal Recursive Collector Function.
Args:
doc (`UI.UIDocument`): Document for the collector.
collector (`FilteredElementCollector`): FilteredElementCollector
filters (`dict`): Filters - {'doc': revit.doc, 'of_class': 'Wall'}
Returns:
collector (`FilteredElementCollector`): FilteredElementCollector
"""
for filter_class in FilterClasses.get_sorted():
if filter_class.keyword not in filters:
continue
filter_value = filters.pop(filter_class.keyword)
logger.debug('Applying Filter: {}'.format(filter_class))
new_collector = filter_class.apply(doc, collector, filter_value)
return self._collect(doc, new_collector, filters)
return collector
def collector_helper(filters):
logger.debug('{}'.format(filters))
collector = rpw.Collector(**filters)
elements = collector.elements
logger.debug(collector)
logger.debug(collector.first)
return collector
def collector_helper(filters):
logger.debug('{}'.format(filters))
collector = rpw.db.Collector(**filters)
elements = collector.elements
logger.debug(collector)
if collector:
logger.debug(collector[0])
return collector
def setUpModule():
logger.title('SETTING UP TESTS...')
logger.title('REVIT {}'.format(version))
collector = DB.FilteredElementCollector(doc)
walls = collector.OfClass(DB.Wall).ToElements()
if walls:
t = DB.Transaction(doc, 'Delete Walls')
t.Start()
for wall in walls:
doc.Delete(wall.Id)
t.Commit()
collector = DB.FilteredElementCollector(doc)
level = collector.OfClass(DB.Level).FirstElement()
pt1 = DB.XYZ(0, 0, 0)
pt2 = DB.XYZ(20, 20, 0)
wall_line = DB.Line.CreateBound(pt1, pt2)
t = DB.Transaction(doc, 'Add Wall')
t.Start()
wall = DB.Wall.Create(doc, wall_line, level.Id, False)
t.Commit()
global wall_int
wall_int = wall.Id.IntegerValue
logger.debug('WALL CREATED.')
collector = DB.FilteredElementCollector(doc)
desk = collector.OfCategory(
DB.BuiltInCategory.OST_Furniture).FirstElement()
if desk:
with rpw.Transaction('Delete Desk'):
f = desk.Family
doc.Delete(f.Id)
##################################################
# Load Fixture Family and Place Instances
##################################################
logger.debug('LOADING SYMBOl')
family_path = os.path.join(test_dir, 'fixtures', 'desk.rfa')
if not os.path.exists(family_path):
raise Exception('Could not find fixture: {}'.format(family_path))
logger.debug('LOADING SYMBOl')
family = clr.Reference[DB.Family]()
with rpw.Transaction('Load Family'):
doc.LoadFamily(family_path, family)
family = family.Value
symbols = []
for family_symbol in family.Symbols:
symbols.append(family_symbol)
with rpw.Transaction('Place Instances'):
level = DB.FilteredElementCollector(doc).OfClass(
DB.Level).WhereElementIsNotElementType().FirstElement()
doc.Create.NewFamilyInstance(DB.XYZ(5, 0, 0), symbols[0], level,
DB.Structure.StructuralType.NonStructural)
doc.Create.NewFamilyInstance(DB.XYZ(10, 4, 0), symbols[0], level,
DB.Structure.StructuralType.NonStructural)
doc.Create.NewFamilyInstance(DB.XYZ(15, 8, 0), symbols[1], level,
DB.Structure.StructuralType.NonStructural)
def tearDown(self):
logger.debug('SELECTION TEST PASSED')
def find_module(self, fullname, path=None):
logger.debug('Loading : {}'.format(fullname))
for module in self.dotnet_modules:
if fullname.startswith(module):
return self
return None
def AddReference(self, namespace):
logger.debug("Mock.clr.AddReference('{}')".format(namespace))
def find_module(self, fullname, path=None):
logger.debug('Loading : {}'.format(fullname))
for module in self.dotnet_modules:
if fullname.startswith(module):
return self
return None
def tearDown(self):
logger.debug('SELECTION TEST PASSED')
logger.error(errmsg)
platform = None
logger.warning('Could not Revit Document. Will Import Sphinx Compat Vars')
from rpw.utils.sphinx_compat import *
# Imported Revit's Assemblies
else:
try:
uidoc = __revit__.ActiveUIDocument
doc = __revit__.ActiveUIDocument.Document
version = __revit__.Application.VersionNumber.ToString()
platform = {'revit': version}
logger.info("Running In Revit")
except NameError:
logger.debug('Could not find pyRevit Document. Trying Dynamo.')
try:
clr.AddReference("RevitServices")
except:
raise Exception('Could Not Find Dynamo Services')
else:
# Adds Built in Library for Dynamo
sys.path.append(r'C:\Program Files (x86)\IronPython 2.7\Lib')
import RevitServices
from RevitServices.Persistence import DocumentManager
from RevitServices.Transactions import TransactionManager
doc = DocumentManager.Instance.CurrentDBDocument
uiapp = DocumentManager.Instance.CurrentUIApplication
app = uiapp.Application
uidoc = DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument
def __init__(self, parameter_reference, **conditions):
"""
Creates Parameter Filter Rule
>>> param_rule = ParameterFilter(param_id, equals=2)
>>> param_rule = ParameterFilter(param_id, not_equals='a', case_sensitive=True)
>>> param_rule = ParameterFilter(param_id, not_equals=3, reverse=True)
Args:
param_id(DB.ElementID): ElementId of parameter
**conditions: Filter Rule Conditions and options.
conditions:
| ``begins``, ``not_begins``
| ``contains``, ``not_contains``
| ``ends``, ``not_ends``
| ``equals``, ``not_equals``
| ``less``, ``not_less``
| ``less_equal``, ``not_less_equal``
| ``greater``, ``not_greater``
| ``greater_equal``, ``not_greater_equal``
options:
| ``case_sensitive``: Enforces case sensitive, String only
| ``reverse``: Reverses result of Collector
"""
parameter_id = self.coerce_param_reference(parameter_reference)
reverse = conditions.get('reverse', False)
case_sensitive = conditions.get('case_sensitive', ParameterFilter.CASE_SENSITIVE)
precision = conditions.get('precision', ParameterFilter.FLOAT_PRECISION)
for condition in conditions.keys():
if condition not in ParameterFilter.RULES:
raise RpwException('Rule not valid: {}'.format(condition))
rules = []
for condition_name, condition_value in conditions.iteritems():
# Returns on of the CreateRule factory method names above
rule_factory_name = ParameterFilter.RULES.get(condition_name)
filter_value_rule = getattr(DB.ParameterFilterRuleFactory,
rule_factory_name)
args = [condition_value]
if isinstance(condition_value, str):
args.append(case_sensitive)
if isinstance(condition_value, float):
args.append(precision)
filter_rule = filter_value_rule(parameter_id, *args)
if 'not_' in condition_name:
filter_rule = DB.FilterInverseRule(filter_rule)
logger.debug('ParamFilter Conditions: {}'.format(conditions))
logger.debug('Case sensitive: {}'.format(case_sensitive))
logger.debug('Reverse: {}'.format(reverse))
logger.debug('ARGS: {}'.format(args))
logger.debug(filter_rule)
logger.debug(str(dir(filter_rule)))
rules.append(filter_rule)
if not rules:
raise RpwException('malformed filter rule: {}'.format(conditions))
_revit_object = DB.ElementParameterFilter(List[DB.FilterRule](rules),
reverse)
super(ParameterFilter, self).__init__(_revit_object)
self.conditions = conditions
def tearDown(self):
self.selection.clear()
logger.debug('SELECTION TEST PASSED')
def tearDown(self):
# Pick().clear()
logger.debug('SELECTION TEST PASSED')
def AddReference(self, namespace):
logger.debug("Mock.clr.AddReference('{}')".format(namespace))
def tearDown(self):
self.selection.clear()
logger.debug('SELECTION TEST PASSED')
def tearDown(self):
# Pick().clear()
logger.debug('SELECTION TEST PASSED')
def __init__(self, parameter_reference, **conditions):
"""
Creates Parameter Filter Rule
>>> param_rule = ParameterFilter(param_id, equals=2)
>>> param_rule = ParameterFilter(param_id, not_equals='a', case_sensitive=True)
>>> param_rule = ParameterFilter(param_id, not_equals=3, reverse=True)
Args:
param_id(DB.ElementID): ElemendId of parameter
**conditions: Filter Rule Conditions and options.
conditions:
| ``begins``, ``not_begins``
| ``contains``, ``not_contains``
| ``ends``, ``not_ends``
| ``equals``, ``not_equals``
| ``less``, ``not_less``
| ``less_equal``, ``not_less_equal``
| ``greater``, ``not_greater``
| ``greater_equal``, ``not_greater_equal``
options:
| ``case_sensitive``: Enforces case sensitive, String only
| ``reverse``: Reverses result of Collector
"""
parameter_id = self.coerce_param_reference(parameter_reference)
reverse = conditions.get('reverse', False)
case_sensitive = conditions.get('case_sensitive', ParameterFilter.CASE_SENSITIVE)
precision = conditions.get('precision', ParameterFilter.FLOAT_PRECISION)
for condition in conditions.keys():
if condition not in ParameterFilter.RULES:
raise RpwException('Rule not valid: {}'.format(condition))
rules = []
for condition_name, condition_value in conditions.iteritems():
# Returns on of the CreateRule factory method names above
rule_factory_name = ParameterFilter.RULES.get(condition_name)
filter_value_rule = getattr(DB.ParameterFilterRuleFactory,
rule_factory_name)
args = [condition_value]
if isinstance(condition_value, str):
args.append(case_sensitive)
if isinstance(condition_value, float):
args.append(precision)
filter_rule = filter_value_rule(parameter_id, *args)
if 'not_' in condition_name:
filter_rule = DB.FilterInverseRule(filter_rule)
logger.debug('ParamFilter Conditions: {}'.format(conditions))
logger.debug('Case sensitive: {}'.format(case_sensitive))
logger.debug('Reverse: {}'.format(reverse))
logger.debug('ARGS: {}'.format(args))
logger.debug(filter_rule)
logger.debug(str(dir(filter_rule)))
rules.append(filter_rule)
if not rules:
raise RpwException('malformed filter rule: {}'.format(conditions))
_revit_object = DB.ElementParameterFilter(List[DB.FilterRule](rules),
reverse)
super(ParameterFilter, self).__init__(_revit_object)
self.conditions = conditions
def setUpModule():
logger.title('SETTING UP TESTS...')
logger.title('REVIT {}'.format(version))
collector = DB.FilteredElementCollector(doc)
walls = collector.OfClass(DB.Wall).ToElements()
if walls:
t = DB.Transaction(doc, 'Delete Walls')
t.Start()
for wall in walls:
doc.Delete(wall.Id)
t.Commit()
collector = DB.FilteredElementCollector(doc)
level = collector.OfClass(DB.Level).FirstElement()
pt1 = DB.XYZ(0, 0, 0)
pt2 = DB.XYZ(20, 20, 0)
wall_line = DB.Line.CreateBound(pt1, pt2)
t = DB.Transaction(doc, 'Add Wall')
t.Start()
wall = DB.Wall.Create(doc, wall_line, level.Id, False)
t.Commit()
global wall_int
wall_int = wall.Id.IntegerValue
logger.debug('WALL CREATED.')
collector = DB.FilteredElementCollector(doc)
desk = collector.OfCategory(DB.BuiltInCategory.OST_Furniture).FirstElement()
if desk:
f = desk.Family
t = DB.Transaction(doc, 'Delete')
t.Start()
doc.Delete(f.Id)
t.Commit()
##################################################
# Load Fixture Family and Place Instances
##################################################
logger.debug('LOADING SYMBOl')
family_path = os.path.join(test_dir, 'fixtures', 'desk.rfa')
if not os.path.exists(family_path):
raise Exception('Could not find fixture: {}'.format(family_path))
logger.debug('LOADING SYMBOl')
family = clr.Reference[DB.Family]()
t = DB.Transaction(doc, 'Delete')
t.Start()
doc.LoadFamily(family_path, family)
t.Commit()
family = family.Value
symbols = []
# for family_symbol in family.Symbols:
for family_symbol_id in family.GetFamilySymbolIds():
family_symbol = doc.GetElement(family_symbol_id)
symbols.append(family_symbol)
t = DB.Transaction(doc)
t.Start('Place Families')
logger.critical('Starting Transactions')
logger.critical(symbols)
try:
[s.Activate() for s in symbols]
except:
pass # Revit < 2016
level = DB.FilteredElementCollector(doc).OfClass(DB.Level).WhereElementIsNotElementType().FirstElement()
doc.Create.NewFamilyInstance(DB.XYZ(5, 0, 0), symbols[0], level, DB.Structure.StructuralType.NonStructural)
doc.Create.NewFamilyInstance(DB.XYZ(10, 4, 0), symbols[0], level, DB.Structure.StructuralType.NonStructural)
doc.Create.NewFamilyInstance(DB.XYZ(15, 8, 0), symbols[1], level, DB.Structure.StructuralType.NonStructural)
t.Commit()
