class BigBoolTestCase(unittest.TestCase):
def setUp(self):
self.policy = Policy()
def tearDown(self):
del self.policy
def testBigBoolArray(self):
biglen = 1000
self.policy.isBool("true")
for i in range(biglen):
self.policy.add("true", True)
v = self.policy.getArray("true")
self.assertEqual(len(v), biglen, "wrong big number of values in array")
for i in range(biglen):
self.assertTrue(v[i], "big array with bad value")
del v
self.assertTrue(True, "Blew up True")
fd = open("/dev/null", "w")
print("look: %s" % True, file=fd)
fd.close()
def testFromPolicy(self):
p = Policy()
p.set("name", "visit")
idf = id.IntegerIDFilter.fromPolicy(p)
self.testNoConstraints(idf)
idf = id.IDFilter.fromPolicy(p)
self.assert_(not isinstance(idf, id.IntegerIDFilter))
p.set("className", "Integer")
idf = id.IDFilter.fromPolicy(p)
self.testNoConstraints(idf)
p.set("className", "IntegerIDFilter")
idf = id.IDFilter.fromPolicy(p)
self.testNoConstraints(idf)
p.set("className", "lsst.ctrl.sched.joboffice.id.IntegerIDFilter")
self.assertRaises(RuntimeError, id.IDFilter.fromPolicy, p)
p.set("className", "Integer")
p.set("min", 3)
idf = id.IDFilter.fromPolicy(p)
self.testMin(idf)
p.set("min", 0)
p.set("lim", 16)
idf = id.IDFilter.fromPolicy(p)
self.testRange(idf)
p.set("value", 20)
p.add("value", 25)
idf = id.IDFilter.fromPolicy(p)
self.testValues4(idf)
def generateDict(self, policy, dictionary, prefix=""):
definitions = Policy()
dictionary.set("definitions", definitions)
names = policy.names(True)
for name in names:
values = policy.getArray(name)
defin = Policy()
definitions.set(name, defin)
defin.set("type", policy.getTypeName(name))
defin.set("minOccurs", 1)
defin.set("maxOccurs", len(values))
type = policy.getValueType(name)
if type == Policy.POLICY:
newPrefix = prefix + "." + name
subdict = Policy()
defin.set("dictionary", subdict)
if len(values) > 1:
print("# Warning: only using first value of", newPrefix)
self.generateDict(values[0], subdict, newPrefix)
else:
allowed = Policy()
defin.set("allowed", allowed)
orderable = type == Policy.INT or type == Policy.DOUBLE \
or type == Policy.STRING
if orderable:
allowed.set("min", min(values))
allowed.set("max", max(values))
for value in values:
defin.add("default", value)
allowed.add("value", value)
def testFromPolicy(self):
p = Policy()
p.set("name", "visit")
idf = id.IntegerIDFilter.fromPolicy(p)
self.testNoConstraints(idf)
idf = id.IDFilter.fromPolicy(p)
self.assert_(isinstance(idf, id.StringIDFilter))
p.set("className", "String")
idf = id.IDFilter.fromPolicy(p)
self.assert_(isinstance(idf, id.StringIDFilter))
self.testNoConstraints(idf)
p.set("className", "StringIDFilter")
idf = id.IDFilter.fromPolicy(p)
self.assert_(isinstance(idf, id.StringIDFilter))
self.testNoConstraints(idf)
p.set("className", "lsst.ctrl.sched.joboffice.id.StringIDFilter")
self.assertRaises(RuntimeError, id.IDFilter.fromPolicy, p)
p.set("className", "String")
p.set("value", "-8")
p.add("value", "r")
p.add("value", "6,0")
idf = id.IDFilter.fromPolicy(p)
self.assert_(isinstance(idf, id.StringIDFilter))
self.testValues2(idf)
def testFromPolicy(self):
p = Policy()
p.set("name", "visit")
idf = id.IntegerIDFilter.fromPolicy(p)
self.testNoConstraints(idf)
idf = id.IDFilter.fromPolicy(p)
self.assert_(isinstance(idf, id.StringIDFilter))
p.set("className", "String")
idf = id.IDFilter.fromPolicy(p)
self.assert_(isinstance(idf, id.StringIDFilter))
self.testNoConstraints(idf)
p.set("className", "StringIDFilter")
idf = id.IDFilter.fromPolicy(p)
self.assert_(isinstance(idf, id.StringIDFilter))
self.testNoConstraints(idf)
p.set("className", "lsst.ctrl.sched.joboffice.id.StringIDFilter")
self.assertRaises(RuntimeError, id.IDFilter.fromPolicy, p)
p.set("className", "String")
p.set("value", "-8")
p.add("value", "r")
p.add("value", "6,0")
idf = id.IDFilter.fromPolicy(p)
self.assert_(isinstance(idf, id.StringIDFilter))
self.testValues2(idf)
def generateDict(self, policy, dictionary, prefix=""):
definitions = Policy()
dictionary.set("definitions", definitions)
names = policy.names(True)
for name in names:
values = policy.getArray(name)
defin = Policy()
definitions.set(name, defin)
defin.set("type", policy.getTypeName(name))
defin.set("minOccurs", 1)
defin.set("maxOccurs", len(values))
type = policy.getValueType(name)
if type == Policy.POLICY:
newPrefix = prefix + "." + name
subdict = Policy()
defin.set("dictionary", subdict)
if len(values) > 1:
print("# Warning: only using first value of", newPrefix)
self.generateDict(values[0], subdict, newPrefix)
else:
allowed = Policy()
defin.set("allowed", allowed)
orderable = type == Policy.INT or type == Policy.DOUBLE \
or type == Policy.STRING
if orderable:
allowed.set("min", min(values))
allowed.set("max", max(values))
for value in values:
defin.add("default", value)
allowed.add("value", value)
def testFromPolicy(self):
p = Policy()
p.set("name", "visit")
idf = id.IntegerIDFilter.fromPolicy(p)
self.testNoConstraints(idf)
idf = id.IDFilter.fromPolicy(p)
self.assert_(not isinstance(idf, id.IntegerIDFilter))
p.set("className", "Integer")
idf = id.IDFilter.fromPolicy(p)
self.testNoConstraints(idf)
p.set("className", "IntegerIDFilter")
idf = id.IDFilter.fromPolicy(p)
self.testNoConstraints(idf)
p.set("className", "lsst.ctrl.sched.joboffice.id.IntegerIDFilter")
self.assertRaises(RuntimeError, id.IDFilter.fromPolicy, p)
p.set("className", "Integer")
p.set("min", 3)
idf = id.IDFilter.fromPolicy(p)
self.testMin(idf)
p.set("min", 0)
p.set("lim", 16)
idf = id.IDFilter.fromPolicy(p)
self.testRange(idf)
p.set("value", 20)
p.add("value", 25)
idf = id.IDFilter.fromPolicy(p)
self.testValues4(idf)
def setUp(self):
p = Policy()
p.set("foo", "bar")
p.set("count", 3)
p.set("files", "goob")
p.add("files", "gurn")
impl = bb.PolicyBlackboardItem()
impl._props = p
self.bbi = bb.ImplBlackboardItem(impl)
self.initCount = 3
def setUp(self):
p = Policy()
p.set("foo", "bar")
p.set("count", 3)
p.set("files", "goob")
p.add("files", "gurn")
impl = bb.PolicyBlackboardItem()
impl._props = p
self.bbi = bb.ImplBlackboardItem(impl)
self.initCount = 3
def setUp(self):
if not os.path.exists(self.propfile):
p = Policy()
p.set("foo", "bar")
p.set("count", 3)
p.set("files", "goob")
p.add("files", "gurn")
w = PAFWriter(self.propfile)
w.write(p, True)
w.close()
self.bbi = bb.PolicyBlackboardItem(self.propfile)
self.initCount = 3
def setUp(self):
if not os.path.exists(self.propfile):
p = Policy()
p.set("foo", "bar")
p.set("count", 3)
p.set("files", "goob")
p.add("files", "gurn")
w = PAFWriter(self.propfile)
w.write(p, True)
w.close()
self.bbi = bb.PolicyBlackboardItem(self.propfile)
self.initCount = 3
def testPostprocess(self):
print "Events in Postprocess..."
pol = Policy()
pol.add("RunMode", "postprocess")
pol.add("keysToPublish", "loose=change")
pol.add("keysToPublish", "planned=obselesence")
self._runStageWithPolicy(pol)
def testFromPolicy(self):
p = Policy()
p.set("datasetType", self.type)
trig = SimpleTrigger.fromPolicy(p)
self.testDatasetType(trig)
trig = Trigger.fromPolicy(p)
self.testDatasetType(trig)
p.set("className", "Simple")
trig = Trigger.fromPolicy(p)
self.testDatasetType(trig)
p.set("className", "SimpleTrigger")
trig = Trigger.fromPolicy(p)
self.testDatasetType(trig)
p.set("className", "lsst.ctrl.sched.joboffice.goober.SimpleTrigger")
self.assertRaises(ImportError, Trigger.fromPolicy, p)
p.set("className", "Simple")
idp = Policy()
idp.set("name", "visit")
idp.set("value", 88)
p.add("id", idp)
idp = Policy()
idp.set("name", "ccd")
idp.set("lim", 9)
p.add("id", idp)
idp = Policy()
idp.set("name", "amp")
idp.set("min", 0)
idp.set("lim", 16)
p.add("id", idp)
trig = SimpleTrigger.fromPolicy(p)
# pdb.set_trace()
self.testIds(trig)
def testDefRunMode(self):
print "Events in Default RunMode..."
pol = Policy()
pol.add("keysToPublish", "loose=change")
pol.add("keysToPublish", "planned=obselesence")
self._runStageWithPolicy(pol)
# non-throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
ve = ValidationError("Dictionary_1.py", 1, "testMergeDefaults")
p.mergeDefaults(pd, False, ve)
self.assert_(ve.getErrors("required") == ValidationError.MISSING_REQUIRED)
self.assert_(ve.getParamCount() == 1)
# non-retention
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
p.mergeDefaults(pd, False)
# make sure validate() fails gracefully when no dictionary present
self.assertRaisesEx(DictionaryError, "No dictionary",
p.validate, "No dictionary assigned")
p.add("unknown", 0) # would be rejected if dictionary was kept
# deep merge from a Policy that's not a Dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.mergeDefaults(Policy(self.getTestDictionary("defaults_policy_most.paf")))
self.assert_(p.nameCount() == 3)
self.assert_(p.getBool("bool_set_count") == True)
self.assert_(p.getString("indirect.string_type") == "bar")
# propagation of a Dictionary from one Policy to another via mergeDefaults
d = Dictionary(self.getTestDictionary("defaults_dictionary_complete.paf"))
d.loadPolicyFiles(self.getTestDictionary())
pEmpty = Policy()
pEmpty.mergeDefaults(d)
self.assert_(pEmpty.canValidate())
pPartial = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
class PolicyBlackboardItem(BlackboardItem):
"""
An implementation of a BlackboardItem that stores properities via a
policy
"""
def __init__(self, policyfile=None):
"""
create an item with the given properties.
@param policyfile A policy
"""
# the properties attached to this items
self._props = None
if policyfile:
self._props = Policy.createPolicy(policyfile)
else:
self._props = Policy()
def getProperty(self, name, default=None):
"""
return the value for a property
@param name the property name
@parma default the default value to return if the name is not set
"""
if not self._props.exists(name):
return default
elif self._props.isArray(name):
return self._props.getArray(name)
else:
return self._props.get(name)
def hasProperty(self, name):
"""
return True if the property with the given name is available
"""
return self._props.exists(name)
def __getitem__(self, name):
if not self._props.exists(name):
raise KeyError(name)
return BlackboardItem.__getitem__(self, name)
def _setProperty(self, name, val):
# set a property value
if isinstance(val, list):
self._props.set(name, val.pop(0))
for v in val:
self._props.add(name, v)
else:
self._props.set(name, val)
def getPropertyNames(self):
"""
return the property names that make up this item
"""
return self._props.names()
def _copyFrom(self, item):
for name in item.getPropertyNames():
self._setProperty(name, item.getProperty(name))
@staticmethod
def createFormatter():
return PolicyBlackboardItem._Fmtr()
class _Fmtr(object):
def write(self, filename, item):
pol = None
if isinstance(item, PolicyBlackboardItem):
pol = item._props
else:
delegate = PolicyBlackboardItem()
delegate._copyFrom(item)
pol = delegate._props
writer = PAFWriter(filename)
try:
writer.write(pol, True)
finally:
writer.close()
def openItem(self, filename):
out = PolicyBlackboardItem()
out._props = Policy.createPolicy(filename)
return out
def filenameExt(self):
"""
return the recommended extension for the format this writes out
"""
return "paf"
def testMergeDefaults(self):
# from a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
d = Dictionary(self.getTestDictionary("defaults_dictionary_good.paf"))
d.loadPolicyFiles(self.getTestDictionary(), True)
self.assert_(p.nameCount() == 2)
p.mergeDefaults(d)
self.assert_(p.valueCount("int_range_count") == 3)
self.assert_(p.nameCount() == 7)
# from a policy that's really a dictionary
p = Policy()
pd = Policy(self.getTestDictionary("defaults_dictionary_indirect.paf"))
p.mergeDefaults(pd)
self.assert_(p.getString("string_type") == "foo")
self.assert_(p.getDictionary().isDictionary())
# from a policy that's really a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
pd = Policy(self.getTestDictionary("defaults_dictionary_policy.paf"))
pd.loadPolicyFiles(self.getTestDictionary(), True)
self.assert_(p.nameCount() == 2)
p.mergeDefaults(pd)
self.assert_(p.valueCount("int_range_count") == 3)
self.assert_(p.nameCount() == 5)
# ensure post-load validation
p.set("int_range_count", -5)
self.assertValidationError(ValidationError.UNKNOWN_NAME,
p.add, "unknown", 0)
# test throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
try:
p.mergeDefaults(pd)
except ValidationError as ve:
self.assert_(ve.getErrors("required")
== ValidationError.MISSING_REQUIRED)
# non-throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
ve = ValidationError("Dictionary_1.py", 1, "testMergeDefaults")
p.mergeDefaults(pd, False, ve.cpp)
self.assert_(ve.getErrors("required") == ValidationError.MISSING_REQUIRED)
self.assert_(ve.getParamCount() == 1)
# non-retention
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
p.mergeDefaults(pd, False)
# make sure validate() fails gracefully when no dictionary present
self.assertRaiseLCE(DictionaryError, "No dictionary",
p.validate, "No dictionary assigned")
p.add("unknown", 0) # would be rejected if dictionary was kept
# deep merge from a Policy that's not a Dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.mergeDefaults(Policy(self.getTestDictionary("defaults_policy_most.paf")))
self.assert_(p.nameCount() == 3)
self.assert_(p.getBool("bool_set_count") == True)
self.assert_(p.getString("indirect.string_type") == "bar")
# propagation of a Dictionary from one Policy to another via mergeDefaults
d = Dictionary(self.getTestDictionary("defaults_dictionary_complete.paf"))
d.loadPolicyFiles(self.getTestDictionary())
pEmpty = Policy()
pEmpty.mergeDefaults(d)
self.assert_(pEmpty.canValidate())
pPartial = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
pPartial.mergeDefaults(pEmpty)
self.assert_(pPartial.canValidate(), "Dictionary handed off via mergeDefaults.")
def testMergeDefaults(self):
# from a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
d = Dictionary(self.getTestDictionary("defaults_dictionary_good.paf"))
d.loadPolicyFiles(self.getTestDictionary(), True)
self.assertEqual(p.nameCount(), 2)
p.mergeDefaults(d)
self.assertEqual(p.valueCount("int_range_count"), 3)
self.assertEqual(p.nameCount(), 7)
# from a policy that's really a dictionary
p = Policy()
pd = Policy(self.getTestDictionary("defaults_dictionary_indirect.paf"))
p.mergeDefaults(pd)
self.assertEqual(p.getString("string_type"), "foo")
self.assertTrue(p.getDictionary().isDictionary())
# from a policy that's really a non-trivial dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
pd = Policy(self.getTestDictionary("defaults_dictionary_policy.paf"))
pd.loadPolicyFiles(self.getTestDictionary(), True)
self.assertEqual(p.nameCount(), 2)
p.mergeDefaults(pd)
self.assertEqual(p.valueCount("int_range_count"), 3)
self.assertEqual(p.nameCount(), 5)
# ensure post-load validation
p.set("int_range_count", -5)
self.assertValidationError(ValidationError.UNKNOWN_NAME,
p.add, "unknown", 0)
# test throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
try:
p.mergeDefaults(pd)
except ValidationError as ve:
self.assertEqual(ve.getErrors("required"),
ValidationError.MISSING_REQUIRED)
# non-throwing validation
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
ve = ValidationError("Dictionary_1.py", 1, "testMergeDefaults")
p.mergeDefaults(pd, False, ve.cpp)
self.assertEqual(ve.getErrors("required"), ValidationError.MISSING_REQUIRED)
self.assertEqual(ve.getParamCount(), 1)
# non-retention
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.set("required", "foo")
p.mergeDefaults(pd, False)
# make sure validate() fails gracefully when no dictionary present
self.assertRaiseLCE(DictionaryError, "No dictionary",
p.validate, "No dictionary assigned")
p.add("unknown", 0) # would be rejected if dictionary was kept
# deep merge from a Policy that's not a Dictionary
p = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
p.mergeDefaults(Policy(self.getTestDictionary("defaults_policy_most.paf")))
self.assertEqual(p.nameCount(), 3)
self.assertIs(p.getBool("bool_set_count"), True)
self.assertEqual(p.getString("indirect.string_type"), "bar")
# propagation of a Dictionary from one Policy to another via mergeDefaults
d = Dictionary(self.getTestDictionary("defaults_dictionary_complete.paf"))
d.loadPolicyFiles(self.getTestDictionary())
pEmpty = Policy()
pEmpty.mergeDefaults(d)
self.assertTrue(pEmpty.canValidate())
pPartial = Policy(self.getTestDictionary("defaults_policy_partial.paf"))
pPartial.mergeDefaults(pEmpty)
self.assertTrue(pPartial.canValidate(), "Dictionary handed off via mergeDefaults.")
def testPolicySetget(self):
p = Policy()
self.assert_(not p.exists("foo"), "empty existence test failed")
self.assertEqual(p.valueCount("foo.bar"), 0,
"empty valueCount test failed")
self.assertRaises(NameNotFound, p.getTypeInfo, "foo")
p.set("doall", "true")
# non-existence tests on a non-empty policy
self.failUnless(not p.exists("foo"),
"non-empty non-existence test failed")
self.assertEqual(p.valueCount("foo.bar"), 0,
"empty valueCount test failed")
self.failUnless(not p.isInt("foo"),
"non-empty non-existence type test failed")
self.assertRaises(NameNotFound, p.getTypeInfo, "foo")
# existence tests
self.assert_(p.exists("doall"), "non-empty existence test failed")
self.assertEquals(p.valueCount("doall"), 1,
"single valueCount test failed")
self.assertRaises(Exception, p.getInt, "doall")
self.assertRaises(Exception, p.getDoubleArray, "doall")
self.assertEquals(p.get("doall"), "true",
"top-level getString failed")
p.set("doall", "duh")
self.assertEquals(p.get("doall"), "duh",
"top-level getString failed")
# test array access
ary = p.getArray("doall")
self.assertEquals(len(ary), 1,
"scalar property has more than one value")
self.assertEquals(ary[0], "duh", "scalar access via array failed")
p.add("doall", "never")
self.assertEquals(p.valueCount("doall"), 2,
"2-elem. valueCount test failed")
self.assertEquals(p.get("doall"), "never", "top-level add failed")
ary = p.getArray("doall")
self.assertEquals(len(ary), 2,
"scalar property has wrong number of values")
self.assertEquals(ary[0], "duh",
"scalar access via (2-el) array failed")
self.assertEquals(ary[-1], "never",
"scalar access via (2-el) array failed")
# test hierarchical access
# list names
# test types
p.set("pint", 5)
self.assertEquals(p.getInt("pint"), 5, "support for type int failed")
self.assertEquals(type(p.get("pint")), type(5),
"auto-typing for int failed")
p.set("pdbl", 5.1)
self.assertAlmostEquals(p.getDouble("pdbl"), 5.1, 7,
"support for type double failed")
self.assertEquals(type(p.get("pdbl")), type(5.1),
"auto-typing for double failed")
p.set("pbool", True)
self.assert_(p.getBool("pbool"), "support for type bool failed")
self.assertEquals(type(p.get("pbool")), type(True),
"auto-typing for bool failed")
p.add("pbool", False)
# test shallow & deep copies
# test raise NameNotFound if not present
try:
p.get("nonexistent")
self.fail() # should never reach here
except Exception, e:
self.assert_(isinstance(e, NameNotFound))
def testPolicySetget(self):
p = Policy()
self.assertFalse(p.exists("foo"), "empty existence test failed")
self.assertEqual(p.valueCount("foo.bar"), 0,
"empty valueCount test failed")
self.assertRaises(lsst.pex.exceptions.Exception, p.getTypeInfo, "foo")
p.set("doall", "true")
# non-existence tests on a non-empty policy
self.assertFalse(p.exists("foo"),
"non-empty non-existence test failed")
self.assertEqual(p.valueCount("foo.bar"), 0,
"empty valueCount test failed")
self.assertFalse(p.isInt("foo"),
"non-empty non-existence type test failed")
self.assertRaises(lsst.pex.exceptions.Exception, p.getTypeInfo, "foo")
# existence tests
self.assertTrue(p.exists("doall"), "non-empty existence test failed")
self.assertEqual(p.valueCount("doall"), 1,
"single valueCount test failed")
self.assertRaises(lsst.pex.exceptions.Exception, p.getInt, "doall")
self.assertRaises(lsst.pex.exceptions.Exception, p.getDoubleArray,
"doall")
self.assertEqual(p.get("doall"), "true", "top-level getString failed")
p.set("doall", "duh")
self.assertEqual(p.get("doall"), "duh", "top-level getString failed")
# test array access
ary = p.getArray("doall")
self.assertEqual(len(ary), 1,
"scalar property has more than one value")
self.assertEqual(ary[0], "duh", "scalar access via array failed")
p.add("doall", "never")
self.assertEqual(p.valueCount("doall"), 2,
"2-elem. valueCount test failed")
self.assertEqual(p.get("doall"), "never", "top-level add failed")
ary = p.getArray("doall")
self.assertEqual(len(ary), 2,
"scalar property has wrong number of values")
self.assertEqual(ary[0], "duh",
"scalar access via (2-el) array failed")
self.assertEqual(ary[-1], "never",
"scalar access via (2-el) array failed")
# test hierarchical access
# list names
# test types
p.set("pint", 5)
self.assertEqual(p.getInt("pint"), 5, "support for type int failed")
self.assertIsInstance(p.get("pint"), int, "auto-typing for int failed")
p.set("pdbl", 5.1)
self.assertAlmostEqual(p.getDouble("pdbl"), 5.1, 7,
"support for type double failed")
self.assertEqual(type(p.get("pdbl")), type(5.1),
"auto-typing for double failed")
p.set("pbool", True)
self.assertTrue(p.getBool("pbool"), "support for type bool failed")
self.assertEqual(type(p.get("pbool")), type(True),
"auto-typing for bool failed")
p.add("pbool", False)
# test shallow & deep copies
# test raise NameNotFound if not present
self.assertRaises(NameNotFound, p.get, "nonexistent")
self.assertRaises(NameNotFound, p.getArray, "nonexistent")
self.assertRaises(NameNotFound, p.getDouble, "nonexistent")
class PolicyBlackboardItem(BlackboardItem):
"""
An implementation of a BlackboardItem that stores properities via a
policy
"""
def __init__(self, policyfile=None):
"""
create an item with the given properties.
@param policyfile A policy
"""
# the properties attached to this items
self._props = None
if policyfile:
self._props = Policy.createPolicy(policyfile)
else:
self._props = Policy()
def getProperty(self, name, default=None):
"""
return the value for a property
@param name the property name
@parma default the default value to return if the name is not set
"""
if not self._props.exists(name):
return default
elif self._props.isArray(name):
return self._props.getArray(name)
else:
return self._props.get(name)
def hasProperty(self, name):
"""
return True if the property with the given name is available
"""
return self._props.exists(name)
def __getitem__(self, name):
if not self._props.exists(name):
raise KeyError(name)
return BlackboardItem.__getitem__(self, name)
def _setProperty(self, name, val):
# set a property value
if isinstance(val, list):
self._props.set(name, val.pop(0))
for v in val:
self._props.add(name, v)
else:
self._props.set(name, val)
def getPropertyNames(self):
"""
return the property names that make up this item
"""
return self._props.names()
def _copyFrom(self, item):
for name in item.getPropertyNames():
self._setProperty(name, item.getProperty(name))
@staticmethod
def createFormatter():
return PolicyBlackboardItem._Fmtr()
class _Fmtr(object):
def write(self, filename, item):
pol = None
if isinstance(item, PolicyBlackboardItem):
pol = item._props
else:
delegate = PolicyBlackboardItem()
delegate._copyFrom(item)
pol = delegate._props
writer = PAFWriter(filename)
try:
writer.write(pol, True)
finally:
writer.close()
def openItem(self, filename):
out = PolicyBlackboardItem()
out._props = Policy.createPolicy(filename)
return out
def filenameExt(self):
"""
return the recommended extension for the format this writes out
"""
return "paf"
