def test_load(self):
# make sure we're looking in the right spot for the plugins whether
# we're in a develop egg or in the released version
dist = working_set.find(Requirement.parse('openmdao.test'))
fact = PkgResourcesFactory(['openmdao.component'], None)
comp = fact.create('openmdao.test.execcomp.ExecComp',
exprs=['x = a+1', 'y=b-2', 'z=x*2'])
comp.a = 4
comp.b = 2
comp.run()
self.assertEqual(comp.x, 5)
self.assertEqual(comp.y, 0)
self.assertEqual(comp.z, 10)
def test_pkg_resources_factory(self):
# NOTE: this test fails if run standalone:
# ImportError: No module named test_egg_save
# Probably need Egg_TestModel.test_egg_save, or adjusted sys.path.
if MODULE_NAME == '__main__':
return
logging.debug('')
logging.debug('test_pkg_resources_factory')
# Write to egg.
egg_info = self.model.save_to_egg(self.model.name, next_egg(),
py_dir=PY_DIR,
child_objs=self.child_objs)
self.egg_name = egg_info[0]
# Create factory.
factory = PkgResourcesFactory(['openmdao.component',
'openmdao.container'],
[os.getcwd()])
# Create and move to test directory.
orig_dir = os.getcwd()
test_dir = 'EggTest'
if os.path.exists(test_dir):
shutil.rmtree(test_dir, onerror=onerror)
os.mkdir(test_dir)
os.chdir(test_dir)
try:
# Check multiple model instances.
self.create_and_check_model(factory, 'test_model_1',
'Hello world!\n')
self.create_and_check_model(factory, 'test_model_2',
'Hello world!\n')
# Check that reloading doesn't clobber existing files.
file_data = 'New and interesting stuff\n'
path = os.path.join('test_model_2', 'Source', EXTERNAL_FILES[2])
out = open(path, 'w')
out.write(file_data)
out.close()
logging.debug('updated %s', path)
self.create_and_check_model(factory, 'test_model_2', file_data)
# Check observations.
global OBSERVATIONS
OBSERVATIONS = []
model = factory.create('Egg_TestModel', name='observed',
observer=observer)
if model is None:
self.fail("Create of 'observed' failed.")
expected = [
('copy', 'Source/xyzzy'),
('copy', 'sub/data2'),
('copy', 'Source/hello'),
('copy', 'sub/data4'),
('complete', 'observed'),
]
self.assertEqual(len(OBSERVATIONS), len(expected))
for i, observation in enumerate(OBSERVATIONS):
state, string, file_fraction, byte_fraction = observation
self.assertEqual(state, expected[i][0])
self.assertEqual(string, expected[i][1])
self.assertEqual(file_fraction, float(i) / float(len(expected) - 1))
# Create a component.
comp = factory.create('Egg_TestModel.Oddball', name='test_comp',
observer=observer)
if comp is None:
self.fail('Create of test_comp failed.')
self.assertEqual(comp.executions, 0)
comp.run()
self.assertEqual(comp.executions, 3)
self.assertEqual(comp.get_pathname(), 'test_comp')
# Create a (sub)component.
sub = factory.create('Egg_TestModel.Oddball.oddcomp',
name='test_sub')
if sub is None:
self.fail('Create of test_sub failed.')
self.assertEqual(sub.get_pathname(), 'test_sub')
# Create a (sub)container.
sub = factory.create('Egg_TestModel.Oddball.oddcont',
name='test_sub')
if sub is None:
self.fail('Create of test_sub failed.')
self.assertEqual(sub.get_pathname(), 'test_sub')
# Try a non-existent entry point.
obj = factory.create('no-such-entry', name='xyzzy')
self.assertEqual(obj, None)
finally:
os.chdir(orig_dir)
shutil.rmtree(test_dir, onerror=onerror)
def get_available_types(groups=None):
"""Return a set of tuples of the form (typename, dist_version), one
for each available plugin type in the given entry point groups.
If groups is None, return the set for all openmdao entry point groups.
"""
if groups is None:
groups = plugin_groups.keys()
else:
badgroups = []
for group in groups:
if group not in plugin_groups:
badgroups.append(group)
if badgroups:
raise RuntimeError(
"Didn't recognize the following entry point groups: %s. Allowed groups are: %s"
% (badgroups, plugin_groups.keys()))
types = []
for fct in _factories:
types.extend(fct.get_available_types(groups))
return sorted(types, _cmp)
# register factory that loads plugins via pkg_resources
_pkg_res_factory = PkgResourcesFactory()
register_class_factory(_pkg_res_factory)
# register factory for simple imports
register_class_factory(ImportFactory())
for group in groups:
if group not in plugin_groups:
badgroups.append(group)
if badgroups:
raise RuntimeError("Didn't recognize the following entry point"
" groups: %s. Allowed groups are: %s" %
(badgroups, plugin_groups.keys()))
types = []
for fct in _factories:
types.extend(fct.get_available_types(groups))
return sorted(types, _cmp)
def get_signature(typname, version=None):
"""Return constructor argument signature for *typname* using the
specified package version. The form of the return value matches that
of :meth:`inspect.getargspec`.
"""
for fct in _factories:
signature = fct.get_signature(typname, version)
if signature is not None:
return signature
return None
# register factory that loads plugins via pkg_resources
register_class_factory(PkgResourcesFactory())
# register factory for simple imports
register_class_factory(ImportFactory())
else: # s1 == s2
return cmp(parse_version(tup1[1]), parse_version(tup2[1]))
def get_available_types(groups=None):
"""Return a set of tuples of the form (typename, dist_version), one
for each available plugin type in the given entry point groups.
If groups is None, return the set for all openmdao entry point groups.
"""
if groups is None:
groups = _plugin_groups
else:
badgroups = []
for group in groups:
if group not in _plugin_groups:
badgroups.append(group)
if badgroups:
raise RuntimeError("Didn't recognize the following entry point groups: %s. Allowed groups are: %s" %
(badgroups, _plugin_groups))
types = []
for fct in _factories:
types.extend(fct.get_available_types(groups))
return sorted(types, _cmp)
# register factory that loads plugins via pkg_resources
_pkg_res_factory = PkgResourcesFactory(groups=_plugin_groups)
register_class_factory(_pkg_res_factory)
# register factory for simple imports
register_class_factory(ImportFactory())
