def set_variable_attributes(self):
# Need to add units
for key in self.variableNames.values():
min_ = self.mhd_data[key].min()
max_ = self.mhd_data[key].max()
self.variableAttributes[key]['actual_min'] = Attribute('actual_min', float(min_))
self.variableAttributes[key]['actual_max'] = Attribute('actual_max', float(max_))
def __init__(self):
"""default pyFileReader constructor
This initializer calls the base class initializer.
The variables dictionary is initialized here and is expected to be populated by the subclassing reader.
"""
super(pyFileReader, self).__init__()
self.variables = {} #created in subclass
self.variableIDs = {} #maps from variable string names to long ids
self.variableNames = {} #maps from long ids to string names
self.globalAttributes = OrderedDict(
) #maps from attribute str names to global attribute objects
self.globalAttributeNames = {} #maps from ids to str names
self.globalAttributeIDs = {} #maps from str names to ids
self.variableAttributes = {
} #maps from variable str names to dictionaries of variable attributes
self.variableAttributeNames = {} #maps from attribute IDs to name
self.variableAttributeIDs = {} #maps from attribute names to IDs
self.globalAttributes['model_name'] = Attribute(
'model_name', 'python_base_model')
self.globalAttributes['python_model'] = Attribute('python_model', 1)
self.debug = False
self.missing_value = -256. * -256. * -256. * -256. * -256. #same as ccmc::defaults::missingValue
self.dummy_variable = pyKameleon.vectorFloat()
self.dummy_variable.append(0)
def getAttrFromIndex(list, index):
for item in list:
if (abs(index) == Attribute.getIndex(list[item])):
if (index > 0):
return Attribute.getValue(list[item])
else:
return Attribute.getInverseValue(list[item])
def dummyMethod_killACharacter(self):
degenerate = Weather()
health = Attribute("Health")
health.setValue(-1)
degenerate.addAttribute(health)
ev = Events.CharacterUpdateEvent(self.characters[self.killerID].getName(), degenerate)
self.mediator.post(ev)
def test900_905_getmaxscore_noweights(self):
correctError = "get_word: "
try:
a = Attribute()
a.get_max_score()
self.fail("Error: no error!")
except ValueError, e:
self.assertEqual(correctError, str(e)[:len(correctError)])
def test000_000_init_blank(self):
a = Attribute()
correct = Attribute(name="Attribute",
attrWeight=1,
words=None,
weights=None,
sentiments=None)
self.assertEquals(a, correct)
def test900_905_getmaxscore_noweights(self):
correctError = "get_word: "
try:
a = Attribute()
a.get_max_score()
self.fail("Error: no error!")
except ValueError, e:
self.assertEqual(correctError, str(e)[:len(correctError)])
def test100_003_score_multiattr(self):
attr1 = Attribute("1", 1, ["burgers"], [1], [0])
attr2 = Attribute("2", 1, ["fries"], [2], [0])
attr3 = Attribute("3", 1, ["tacos"], [3], [0])
packet = SearchPacket([attr1, attr2, attr3])
score = Scorer(packet)
text = "I hate tacos and love fries and burgers are okay."
self.assertEquals(score.score(text), [1, 2, 3, 0, 0])
def destroyAttribute(self, attribute: Attribute):
try:
if attribute.getType() in self._pool:
self._pool[attribute.getType()].remove(attribute)
return True
else:
print("Trying to remove attribute with an unknown type:")
print(attribute.getType())
except ValueError:
print("Trying to remove attribute that shouldn't exist:")
print(attribute)
return False
def _load(self, config):
"""Initialise deidentification methods
"""
if config.RetainPatientCharacteristicsOption:
# TODO: later this will be replaced with real loading
method = DeidentMethod(
"Retain Patient Characteristics Option",
"Retention of information that would otherwise be removed during de-identification according to an option defined in PS 3.15 that requires that any physical characteristics of the patient, which are descriptive rather than identifying information per se, be retained. E.g., Patient's Age, Sex, Size (height) and Weight.",
"113108", DeidentMethodType.OPTION)
method.Attributes.append(
Attribute("Ethnic Group", "0010", "2160",
KeepAttributeAction()))
method.Attributes.append(
Attribute("Patient Sex Neutered", "0010", "2203",
KeepAttributeAction()))
method.Attributes.append(
Attribute("Patient's Age", "0010", "1010",
KeepAttributeAction()))
method.Attributes.append(
Attribute("Patient's Sex", "0010", "0040",
KeepAttributeAction()))
method.Attributes.append(
Attribute("Patient's Size", "0010", "1020",
KeepAttributeAction()))
method.Attributes.append(
Attribute("Patient's Weight", "0010", "1030",
KeepAttributeAction()))
method.Attributes.append(
Attribute("Pregnancy Status", "0010", "21C0",
KeepAttributeAction()))
method.Attributes.append(
Attribute("Smoking Status", "0010", "21A0",
KeepAttributeAction()))
self._methods.append(method)
def GetAttributes(text):
from settings import AttributeDefinition,FinalDefinition
from settings import PrivateDefinition,PublicDefinition
from settings import ProtectedDefinition,StaticDefinition
text = CleanUnusedLogicalBlocks(text)
Attributes = []
for attributedef in AttributeDefinition:
lines = text.split(attributedef[1])
for line in lines:
type = ""
tmp_line = line.replace("\n","").replace(" "," ")
if tmp_line.replace(" ","") =="":
break
for attribute in tmp_line.split(','):
a = Attribute()
atr = attribute
if atr.find("=")>-1:
a.Value=atr[atr.find("=")+1:]
atr = atr[:atr.find("=")]
for word in atr.split():
if (word==PrivateDefinition.replace(" ","")):
a.Private=True
atr= atr.replace(word,"")
elif (word==PublicDefinition.replace(" ","")):
a.Public =True
atr= atr.replace(word,"")
elif (word==ProtectedDefinition.replace(" ","")):
a.Protected=True
atr= atr.replace(word,"")
elif (word==FinalDefinition.replace(" ","")):
a.Final = True
atr=atr.replace(word,"")
elif (word==StaticDefinition.replace(" ","")):
a.Static=True
atr= atr.replace(word,"")
elif (word in DataTypes):
type=word
atr= atr.replace(word,"")
if len(atr.split())==1:
a.Name=atr.split()[0]
elif len(atr.split())==2:
type = atr.split()[0]
a.Name=atr.split()[1]
else:
raise ValueError("nerozpoznane paramtre v nazve atributu v pocte "+str(len(atr.split()))+" text: ",atr)
a.Type = type
Attributes.append(a)
text = text.replace(line,"")
return Attributes,text
def setUp(self):
self.attr1 = Attribute()
self.attr1.name = "one"
self.attr1.set_words(["one", "two", "three"])
self.attr1.set_weights([1, 2, 3])
self.attr1.set_sentiments([1, 1, 1])
self.attr2 = Attribute()
self.attr2.name = "two"
self.attr2.set_words(["four", "five", "six"])
self.attr2.set_weights([3, 2, 1])
self.attr2.set_sentiments([-1, 1, -1])
self.attrs = [self.attr1, self.attr2]
self.packet = SearchPacket(self.attrs)
def setUp(self):
print 'Variable Attribute test:'
self.testReader = pyFileReader()
self.testReader.variables['power'] = fillRandom()
self.testReader.variables['money'] = fillRandom('int')
self.testReader.initializeVariableIDs()
self.unitsAttr = Attribute('unit', '[J/s]')
self.testReader.variableAttributes['power']['units'] = self.unitsAttr
self.testReader.variableAttributes['power']['amount'] = Attribute(
'value', 9001.)
self.testReader.variableAttributes['money']['units'] = Attribute(
'unit', 'pesos')
self.testReader.variableAttributes['money']['amount'] = Attribute(
'value', 'over 9000!!')
self.testReader.initializeVariableAttributeIDs()
def setUp(self): self.attr1 = Attribute() self.attr1.name = "one" self.attr1.set_words(["one", "two", "three"]) self.attr1.set_weights_nums([1,2,3]) self.attr1.set_sentiments_nums([1,1,1]) self.attr2 = Attribute() self.attr2.name = "two" self.attr2.set_words(["four", "five", "six"]) self.attr2.set_weights_nums([3,2,1]) self.attr2.set_sentiments_nums([-1,1,-1]) self.attrs = [self.attr1, self.attr2] self.packet = SearchPacket(self.attrs)
def setUp(self):
self.words = ['pizza', 'tacos', 'burgers', 'fries']
weights = [1, 3, 2, 2]
sentiments = [1, 1, 1, 1]
attribute = Attribute("Attribute1", 1, self.words, weights, sentiments)
self.packet = SearchPacket([attribute])
self.scorer = Scorer(self.packet)
def dtree_booster(training_set, iterations, attributes):
num_exs = np.size(training_set, 0)
w = (1.0 / float(num_exs)) * np.ones((1, num_exs))
classifiers = {}
epsilons = {}
alphas = {}
# We treat our decision tree as a special case, because we end up
# sorting our training set so many times (anytime we are finding a contin-
# uous split). Thus, we tack on the weight as an extra attribute, and
# add it to the list of attributes
weight_index = len(attributes) - 1
# insert column of weights
training_set = np.insert(training_set, weight_index, w, 1)
# update attributes dictionary
attributes['WEIGHTS'] = Attribute('weights', 'WEIGHTS', '0', weight_index)
attributes['CLASS'].index = weight_index + 1
for i in xrange(iterations):
classifiers[i] = get_classifier(training_set, attributes)
epsilons[i] = calc_epsilon(training_set, classifiers[i])
alphas[i] = calc_alpha(epsilons[i])
update_weights(training_set, classifiers[i], alphas[i])
return classifiers, alphas
def test110_900_generatename_Unbalanced(self):
correctError = "generate_name: "
try:
Attribute().generate_name(["word"], [1, 2])
self.fail("Error: no error!")
except ValueError, e:
self.assertEqual(correctError, str(e)[:len(correctError)])
def test110_900_generatename_None(self):
correctError = "generate_name: "
try:
Attribute().generate_name(None, None)
self.fail("Error: no error!")
except ValueError, e:
self.assertEqual(correctError, str(e)[:len(correctError)])
def test000_001_init_notBlank(self):
a = Attribute("test", 2, ["test"], [1], [3])
self.assertEquals(a.name, "test")
self.assertEquals(a.attrWeight, 2)
self.assertEquals(a.words, ["test"])
self.assertEquals(a.weights, [1])
self.assertEquals(a.sentiments, [3])
def sumOp(attr: Attribute):
assert attr.type in [AttrTypes.INT,
AttrTypes.FLOAT], "wrong attribute type"
res = 0
for i in range(attr.getSize()):
res += attr[i]
return res
def build(self, data=None, attributeSet=None):
if attributeSet is None:
# build an attribute set.
aa = AttributeSet()
for line in data:
if line[0] == '@':
aa.add(Attribute(line[1:].split('\t')))
return aa
else:
# build an example set.
ee = ExampleSet()
for line in data:
if type(line) == type(str()):
if line[0] == '#':
ee.add(Example(line[1:], attributeSet))
#elif type(line) == type(ExampleSet()):
# ee.add(line)
else:
ee.add(line)
return ee
def sanitizeAttribute(self, attr):
if attr.get_name() is None or attr.get_name() == "":
raise ValueError("sanitizeAttribute: Invalid name for attribute.")
if attr.get_name() in [a.get_name() for a in self.attributes]:
raise ValueError("sanitizeAttribute: Duplicate name for an attribute.")
if attr.get_attr_weight_num() < 1 or attr.get_attr_weight_num() > 3:
raise ValueError("sanitizeAttribute: Bad attribute weight.")
dirtyWords = attr.get_words()
dirtyWeights = attr.get_weights()
dirtySents = attr.get_sentiments()
if dirtyWords is None or dirtyWeights is None or dirtySents is None:
raise ValueError("sanitizeAttribute: Unassigned values in attribute.")
elif len(dirtyWords) != len(dirtyWeights) or len(dirtyWords) != len(dirtySents):
raise ValueError("sanitizeAttribute: list length mismatch.")
cleanWords, cleanWeights, cleanSents = self.cleanInfoLists(dirtyWords,
dirtyWeights, dirtySents)
if len(cleanWords) < 1:
raise ValueError("sanitizeAttribute: no valid words in attribute.")
return Attribute(attr.get_name(), attr.get_attr_weight_num(),
cleanWords, cleanWeights, cleanSents)
def get_attrib(self, s_attrib):
"""
TODO : perform all dict gets in the right way. No more check if None
etc; instead find the recommended access method and replace
NOTE :
- attribute is a string, get the particular attribute object
and pass the symbol's object to it; it will get the prices
and compute the attribute's values
"""
existing_attrib = self.attrib_dict.get(s_attrib)
if existing_attrib is None:
attrib_root_name = s_attrib[0:s_attrib.index('_')]
attrib_options = s_attrib[s_attrib.index('_') + 1:]
new_attrib = Attribute.get_attrib_dict().get(attrib_root_name)()
if new_attrib is None:
raise Exception('This attribute hasn\'t been defined yet')
new_attrib.options_from_str(attrib_options)
existing_attrib = self.attrib_dict[s_attrib] = new_attrib
existing_attrib.calculate(symbol=self)
return existing_attrib
class AttributeContainer(
with_metaclass(AttributeNotary, AbstractAttributeContainer)):
from Attribute import Attribute
name = Attribute('name')
def set(self, name, value):
exec("self.%s = value" % name)
return
def get(self, name):
exec("value = self.%s" % name)
return value
def __iter__(self):
attributes = list(self.__dict__.keys())
return attributes.__iter__()
def copy(self):
ret = self.__class__(self.name)
for k in self:
ret.set(k, self.get(k))
return ret
def __setattr__(self, name, value):
if name not in self._attributes:
raise AttributeError("Unknown attribute %s" % name)
return object.__setattr__(self, name, value)
pass
def get_attrib(self, s_attrib):
"""
TODO : perform all dict gets in the right way. No more check if None
etc; instead find the recommended access method and replace
NOTE :
- attribute is a string, get the particular attribute object
and pass the symbol's object to it; it will get the prices
and compute the attribute's values
"""
existing_attrib = self.attrib_dict.get(s_attrib)
if existing_attrib is None:
attrib_root_name = s_attrib[0:s_attrib.index('_')]
attrib_options = s_attrib[s_attrib.index('_')+1:]
new_attrib = Attribute.get_attrib_dict().get(attrib_root_name)()
if new_attrib is None:
raise Exception('This attribute hasn\'t been defined yet')
new_attrib.options_from_str(attrib_options)
existing_attrib = self.attrib_dict[s_attrib] = new_attrib
existing_attrib.calculate(symbol=self)
return existing_attrib
def test000_902_sanitize_badWeight(self):
correctError = "sanitizeAttribute: "
try:
test = Attribute("test", 0, ["one", "two"], [1, 1], [1, 1])
self.packet.sanitizeAttribute(test)
self.fail("Error: no error!")
except ValueError, e:
self.assertEqual(correctError, str(e)[:len(correctError)])
def test000_903_sanitize_noWords(self):
correctError = "sanitizeAttribute: "
try:
test = Attribute("one", 1, None, [1, 1], [1, 1])
self.packet.sanitizeAttribute(test)
self.fail("Error: no error!")
except ValueError, e:
self.assertEqual(correctError, str(e)[:len(correctError)])
def createAttribute(self, attributeName : str = None):
if attributeName not in self._names:
print("No AttributeType named " + attributeName + " exists in the pool")
return None
else:
currentType = self._names[attributeName]
self._pool[currentType].append(Attribute(currentType))
return self._pool[currentType][-1]
def test000_905_sanitize_NoSents(self):
correctError = "sanitizeAttribute: "
try:
test = Attribute("one", 1, ["one", "two"], [1, 1], None)
self.packet.sanitizeAttribute(test)
self.fail("Error: no error!")
except ValueError, e:
self.assertEqual(correctError, str(e)[:len(correctError)])
def setUpClass(self):
self.interface = SearchInterface()
attribute = Attribute("Test Attribute",
attrWeight=1,
words=['pizza'],
weights=[3],
sentiments=[1])
self.attributes = [attribute]
self.que = Queue.Queue()
def setUpClass(self):
words = ['pizza', 'tacos', 'burgers', 'fries']
weights = [1, 3, 2, 2]
sentiments = [1, 1, 1, 1]
self.args = {'location': None, 'since': None, 'until': None}
attribute = Attribute("Attribute1", 1, words, weights, sentiments)
attributes = [attribute]
search_packet = SearchPacket(attributes)
self.scorer = Scorer(search_packet)
def test100_002_score_mixed(self):
weights = [1, 3, 2, 2]
sentiments = [0, 0, 0, 0]
attribute = Attribute("Attribute1", 1, self.words, weights, sentiments)
packet = SearchPacket([attribute])
score = Scorer(packet)
text = "I hate tacos and love fries."
#tacos has weight 3, fries 2
self.assertEquals(score.score(text), [5, 0, 0, 0, 0])
def setGlobalAttributes(self):
if self.file_tree.has_key('global_attributes'):
for k, v in self.file_tree['global_attributes'].items():
self.globalAttributes[str(k)] = Attribute(str(k), v)
else:
error_str = "Could not find 'global_attributes' in asdf file"
if self.debug: print error_str
raise NameError(error_str)
self.initializeGlobalAttributeIDs() #after all global attributes set
def getFunctionalDependencies(self, relation):
FDs=[]
for dependencies in relation.iter('dependencies'):
for fd in dependencies:
fdObj=FunctionalDependency.FunctionalDependency()
for lhs in fd.iter('lhs'):
for attribute in lhs:
attribute_object = Attribute(attribute.text)
fdObj.leftHandSide.append(attribute_object)
for rhs in fd.iter('rhs'):
for attribute in rhs:
attribute_object = Attribute(attribute.text)
fdObj.rightHandSide.append(attribute_object)
FDs.append(fdObj)
return FDs
def setUpClass(self):
words = ['pizza', 'tacos', 'burgers', 'fries']
weights = [1, 3, 2, 2]
sentiments = [1, 1, 1, 1]
self.query = "pizza OR tacos OR burgers OR fries"
attribute = Attribute("Attribute1", 1, words, weights, sentiments)
attributes = [attribute]
search_packet = SearchPacket(attributes)
self.scorer = Scorer(search_packet)
self.db = dbFacade()
def parse(self, inStream):
newStream = inStream.split( )
newAttribute = Attribute.factory(newStream[2])
newAttribute.setName(newStream[1])
for num in range(2, len(newStream)):
if type(newAttribute) == NominalAttribute:
newAttribute.addValue(newStream[num])
else:
pass
self.add(newAttribute)
self.setClassIndex(self.getSize()-1)
def add_attribute(self,attribute):
attr_varname = attribute.getAttribute('varname')
attr_name = attribute.getAttribute('name')
attr_type = attribute.getAttribute('type')
attr_description = attribute.getAttribute('description')
attr_label = attribute.getAttribute('label')
attr_fixed = attribute.getAttribute('fixed')
allowed_values = []
allowed_default = ""
if attr_fixed == "choice":
for allowed in attribute.getElementsByTagName('allowed'):
allowed_value = allowed.getAttribute("value")
allowed_label = allowed.getAttribute("label")
if allowed.getAttribute("default") == "default":
allowed_default = allowed_value
allowed_values.append((allowed_value,allowed_label))
if allowed_default == "":
allowed_default = allowed_values[0][0]
typefunc = str
if (attr_type == "float"):
typefunc = float
elif (attr_type == "int" or attr_type == "integer"):
typefunc = int
attr_default = typefunc(attribute.getAttribute('default'))
if attr_fixed == "choice":
attr_default = allowed_default
attr_min = typefunc(attribute.getAttribute('min'))
attr_max = typefunc(attribute.getAttribute('max'))
attr = Attribute(attr_name,attr_varname,attr_type,attr_default,
attr_min,attr_max,attr_label,attr_description,
allowed_values)
attr.order = self.attr_idx
self.attr_idx += 1
self.attributes[attr_varname] = attr
setattr(self,attr_varname,attr.get())
def parse(self, parserContext):
assembly = Assembly()
token = parserContext.get_next_token()
if token != '.assembly':
raise ParseException('Expected .assembly, found ' . token)
token = parserContext.get_next_token()
if token == 'extern':
assembly.extern = True
token = parserContext.get_next_token()
assembly.name = token
while True:
token = parserContext.get_next_token()
if token == '.ver':
assembly.version = parserContext.get_next_token()
elif token == '.hash':
if parserContext.get_next_token() != 'algorithm':
raise ParseException('Expected token "algorithm"')
assembly.hashAlgorithm = int(parserContext.get_next_token(), 16)
elif token == '.custom':
if parserContext.get_next_token() != 'instance':
raise ParseException('Expected token "instance"')
if parserContext.get_next_token() != 'void':
raise ParseException('Expected token "void"')
attribute = Attribute()
attribute.name = parserContext.get_next_token() + '(' + parserContext.get_next_token() + ')'
assembly.customAttributes.append(attribute)
elif token == '{':
pass
elif token == '}':
break
#fixme public key token
return assembly
def nominalToBinary(self):
newDataSet = DataSet()
newAttributes = Attributes()
for items in self.attributes.attributes:
if len(items.domain) > 2:
binaryDomain = bin(len(items.domain))
for index, char in enumerate(str(binaryDomain)):
if index >= len(str(binaryDomain))-2:
pass
else:
newAttribute = Attribute.factory("nominal")
newAttribute.setName(items.name + str(index))
newAttribute.addValue(str(0))
newAttribute.addValue(str(1))
newAttributes.add(newAttribute)
else:
newAttributes.add(items)
newDataSet.setAttributes(newAttributes)
newDataSet.attributes.setClassIndex(len(newAttributes.attributes)-1)
#ADJUST EXAMPLES NEXT
return newDataSet
class test_SearchPacket(unittest.TestCase):
def setUp(self):
self.attr1 = Attribute()
self.attr1.name = "one"
self.attr1.set_words(["one", "two", "three"])
self.attr1.set_weights_nums([1,2,3])
self.attr1.set_sentiments_nums([1,1,1])
self.attr2 = Attribute()
self.attr2.name = "two"
self.attr2.set_words(["four", "five", "six"])
self.attr2.set_weights_nums([3,2,1])
self.attr2.set_sentiments_nums([-1,1,-1])
self.attrs = [self.attr1, self.attr2]
self.packet = SearchPacket(self.attrs)
#sanitize
#pass
def test000_000_sanitizeAttribute(self):
test = Attribute("test", 1, ["one", "two"], [1,1], [1,1])
sanitize = self.packet.sanitizeAttribute(test)
self.assertEquals(sanitize, test)
def test000_001_sanitize_oneBadWord(self):
test = Attribute("test", 1, ["one", ""], [1,1], [1,1])
correct = Attribute("test", 1, ["one"], [1], [1])
self.assertEquals(self.packet.sanitizeAttribute(test), correct)
def test000_002_sanitize_oneBadWeight(self):
test = Attribute("test", 1, ["one", "two"], [1,0], [1,1])
correct = Attribute("test", 1, ["one"], [1], [1])
self.assertEquals(self.packet.sanitizeAttribute(test), correct)
def test000_003_sanitize_oneBadSent(self):
test = Attribute("test", 1, ["one", "two", "three"], [1,1, 1], [1, 0, 2])
correct = Attribute("test", 1, ["one", "two"], [1,1], [1,0])
self.assertEquals(self.packet.sanitizeAttribute(test), correct)
def test000_004_sanitize_oneDupWord(self):
test = Attribute("test", 1, ["one", "one"], [1,1], [1,1])
correct = Attribute("test", 1, ["one"], [1], [1])
self.assertEquals(self.packet.sanitizeAttribute(test), correct)
#fail
def test000_900_sanitize_badName(self):
correctError = "sanitizeAttribute: "
try:
test = Attribute("", 1, ["one", "two"], [1,1], [1,1])
self.packet.sanitizeAttribute(test)
self.fail("Error: no error!")
except ValueError, e:
self.assertEqual(correctError, str(e)[:len(correctError)])
except Exception, e:
self.fail(str(e))
def weather(self):
# Create Weather Class as a container to what will happen during time
# THIS NEEDS TO BE SET TO PRACTICAL DEGENERATIVE PARAMETERS
time = Weather()
# Add Attributes this Weather will help
morale = Attribute("Morale")
morale.setValue(-1)
time.addAttribute(morale)
hygiene = Attribute("Hygiene")
hygiene.setValue(-1)
time.addAttribute(hygiene)
hunger = Attribute("Hunger")
hunger.setValue(-1)
time.addAttribute(hunger)
fatigue = Attribute("Fatigue")
fatigue.setValue(-1)
time.addAttribute(fatigue)
health = Attribute("Health")
health.setValue(-100)
time.addAttribute(health)
# Post as a Cluster Weather Event
ev = Events.ClusterWeatherEvent(0, time)
self.mediator.post(ev)
def test110_001_generatename_blank(self): words = [] weights = [] test = Attribute() self.assertEquals(test.generate_name(words, weights), "")
class test_Attribute(unittest.TestCase):
def setUp(self):
self.test = Attribute("test", 1, ["tests"], [1], [-1])
#__init__
#pass
def test000_000_init_blank(self):
a = Attribute()
correct = Attribute(name = "Attribute", attrWeight = 1,
words = None, weights = None, sentiments = None)
self.assertEquals(a, correct)
def test000_001_init_notBlank(self):
a = Attribute("test", 2, ["test"], [1], [3])
self.assertEquals(a.name, "test")
self.assertEquals(a.attrWeight, 2)
self.assertEquals(a.words, ["test"])
self.assertEquals(a.weights, [1])
self.assertEquals(a.sentiments, [3])
#__eq__
def test100_000_eq(self):
one = Attribute("test", 2, ["test"], [1], [1])
two = Attribute("test", 2, ["test"], [1], [1])
self.assertEquals(one, two)
def test100_001_eq_noteq_name(self):
one = Attribute("test", 2, ["test"], [1], [1])
two = Attribute("test1", 2, ["test"], [1], [1])
self.assertNotEquals(one, two)
def test100_002_eq_noteq_weight(self):
one = Attribute("test", 2, ["test"], [1], [1])
two = Attribute("test", 3, ["test"], [1], [1])
self.assertNotEquals(one, two)
def test100_003_eq_noteq_words(self):
one = Attribute("test", 2, ["test"], [1], [1])
two = Attribute("test", 2, ["test", "test2"], [1], [1])
self.assertNotEquals(one, two)
def test100_004_eq_noteq_weights(self):
one = Attribute("test", 2, ["test"], [1], [1])
two = Attribute("test", 2, ["test"], [1,2], [1])
self.assertNotEquals(one, two)
def test100_005_eq_noteq_sent(self):
one = Attribute("test", 2, ["test"], [1], [3])
two = Attribute("test", 2, ["test"], [1], [1, -1])
self.assertNotEquals(one, two)
#set_name
def test200_000_setname(self):
self.test.set_name("realname")
correct = Attribute("realname", 1, ["tests"], [1], [-1])
self.assertEquals(self.test, correct)
def test200_001_setname_Attribute(self):
self.test.set_name("Attribute")
correct = Attribute("tests", 1, ["tests"], [1], [-1])
self.assertEquals(self.test, correct)
def test200_002_setname_withNone(self):
test = Attribute("name", 1, ["test"])
test.set_name("realname")
correct = Attribute("realname", 1, ["test"])
self.assertEquals(test, correct)
#set_attr_weight
def test300_000_setattrweight(self):
self.test.set_attr_weight(3)
correct = Attribute("test", 1, ["tests"], [1], [-1])
self.assertEquals(self.test, correct)
#set_words
def test400_000_setwords(self):
self.test.set_words(["real", "words"])
correct = Attribute("test",1, ["real", "words"], [1], [-1])
self.assertEquals(self.test, correct)
#set_weight
def test500_000_setweights(self):
self.test.set_weights(["High", "Low", "Blah", "Medium"])
correct = Attribute("test", 1, ["tests"], [3,1,1,2], [-1])
self.assertEquals(self.test, correct)
def test500_001_setweights_blank(self):
self.test.set_weights([])
correct = Attribute("test", 1, ["tests"], [], [-1])
self.assertEquals(self.test, correct)
def test500_900_setweights_notstring(self):
correctError = "set_weights: "
try:
self.test.set_weights([1])
self.fail("Error: no error!")
except ValueError, e:
self.assertEqual(correctError, str(e)[:len(correctError)])
except Exception, e:
self.fail(str(e))
def test900_006_getsize_none(self): a = Attribute() self.assertEquals(a.get_size(), 0)
def setUp(self):
self.test = Attribute("test", 1, ["tests"], [1], [-1])
def test200_002_setname_withNone(self):
test = Attribute("name", 1, ["test"])
test.set_name("realname")
correct = Attribute("realname", 1, ["test"])
self.assertEquals(test, correct)
def test900_012_getweights_none(self): a = Attribute() self.assertIsNone(a.get_words())
def test110_000_generatename(self): words = ["not this", "not this", "this", "not this"] weights = [1,2,3,3] test = Attribute() self.assertEquals(test.generate_name(words, weights), "this")
def test900_014_getsentiments_none(self): a = Attribute() self.assertIsNone(a.get_sentiments())
def ConvertParameterToAttribute(self,param):
atr = Attribute()
atr.Name=param.Name
atr.Type = param.Type
self.Attributes.append(atr)
