class TestTree(TestCase):
def setUp(self):
self.root = Step(None, (0, 0), "O")
self.leaf1 = self.root.add_leaf(1, ".")
self.leaf11 = self.leaf1.add_leaf(1, ".")
self.leaf113 = self.leaf11.add_leaf(3, ".")
self.leaf1132 = self.leaf113.add_leaf(2, ".")
def test_terminal(self):
self.assertSequenceEqual([self.leaf1132],
self.root.get_terminal_leafs())
def test_loop(self):
self.leaf11324 = self.leaf1132.add_leaf(4, 'X')
self.assertIsNone(self.leaf11324)
def test_traverse(self):
for node in self.leaf1132.go_upstream():
print(node.coords, node.depth, node.value)
def test_search(self):
self.assertIsNone(self.root.search_by_value('X'))
self.assertSequenceEqual(self.root.search_by_value("O"), [self.root])
self.assertSetEqual(
set(self.root.search_by_value(".")),
{self.leaf1, self.leaf11, self.leaf113, self.leaf1132})
def test_print(self):
self.assertEqual(str(self.leaf11), "(0, -2) - .")
def run(self, iter=None):
i = iter
if self.time.expression:
runtime = eval(self.time.saved, {}, {'i': i})
else:
runtime = self.time.saved
Step.pause(self, runtime)
def handle_route(route, station2, wayList, step, way):
# todo 方向
if route.prevStation is not None:
step += 1
stepO = Step(route.prevStation, route.line)
if route.prevStation == station2:
way.appendStep(stepO)
Manager.minStep = min(step, Manager.minStep)
wayList.append(way)
return
if step >= Manager.minStep:
return
newWay = copy.copy(way)
newWay.appendStep(stepO)
find
else :
if route.nextStation == station2:
step = Step(route.nextStation, route.line)
way.appendStep(step)
return
if route.prevStation
def __init__(self, _super):
Step.__init__(self, _super)
self.Valve = LabelEntry(self.box, 0, 0, "Valve:", width=16)
self.Valve.expression = False
self.State = LabelEntry(self.box, 0, 2, "State:", width=16)
self.State.expression = False
self.entries = [self.Valve, self.State]
self.steptype = "ValveStep"
def __init__(self, _super):
Step.__init__(self, _super)
self.box.config(text = self.parameter)
self.temp = LabelEntry(self.box, 0, 2, "Temperature (C): ")
self.time = LabelEntry(self.box, 0, 0, "Time (s):")
self.entries.append(self.time)
self.entries.append(self.temp)
self.steptype = "TempStep"
def __init__(
self, _super
): # super is a reference to the procedure holding the item instance
Step.__init__(self, _super)
self.steptype = "PauseStep"
self.time = LabelEntry(self.box, 0, 0, "Time (s):")
self.time.expression = None
self.entries.append(self.time)
def run(self, cleanup = None, iter = None, time = None):
self.setPoint(self.temp.saved)
self.box.config(bg='green')
self.timerWidget.config(text="Waiting to reach set point...")
while abs(self.getTemp() - self.temp.saved) > 1:
self.event.wait(1)
self.checkIfCancel()
print("Equilibrating...")
Step.pause(self, self.time.saved)
def __init__(self, id, request, state):
Step.__init__(self, id, request, state)
self.results = [self._is_not_installed(),
util.check_python_version((2, 3, 0, '', 0)),
util.check_dir_exists(config.data_dir),
util.check_is_writable(config.data_dir),
util.check_python_module_exists('pywsgi'),
util.check_python_module_exists('SpiffGuard'),
util.check_python_module_exists('SpiffIntegrator'),
util.check_python_module_exists('SpiffSignal'),
util.check_python_module_exists('SpiffWarehouse'),
util.check_python_module_exists('SpiffWikiMarkup')]
self.failed = False in [r for n, r, e in self.results]
def saveEntries(self, type="float", iters=None):
timeEntry = self.time.get()
if not iters:
time = float(timeEntry)
if time < 0:
raise ValueError(
"Invalid pause time: " + self.timeEntry +
"; you cannot pause for a negative amount of time.")
self.time.expression = False
else:
self.recursiveIterCheck(iters, timeEntry, self.inputCheckForPause,
())
self.time.expression = True
Step.saveEntries(self)
def __init__(self, size):
self.size = size
self.steps = []
# set first step IC to all zeros
cols = []
for i in range(size):
cols.append([])
for j in range(size):
cols[i].append(0)
init_step = Step(self.size)
init_step.set_init_cond(cols)
self.steps.append(init_step)
def step_of_current(self, passedTime=None, holdingTime=0.0):
return Step(
self.curState.stateId,
copy.copy(self.curState.apSet),
passedTime=passedTime,
holdingTime=holdingTime
)
def _next_step(self, passedtime, duration):
key = tuple([v.get_value() for v in self._vars.values()])
enabled_cmds = self._state_cmd_map[key]
next_move = self._next_move(passedtime, enabled_cmds)
if passedtime + next_move.holding_time > duration:
next_move = NextMove(passedtime)
apset = self._state_ap_map[key]
return Step(apset, next_move)
def __init__(self, _super):
Step.__init__(self, _super)
self.box.config(text="Pump")
self.rate = LabelEntry(self.box, 0, 0, "Rate (cycles/s):", width=3)
self.nCycles = LabelEntry(self.box, 0, 2, "Number of Cycles:", width=9)
self.steptype = "PumpStep"
valvesbox = LabelFrame(self.box)
valvesbox.grid(row=1, column=0, columnspan=10)
self.valveEntries = []
for valve in (1, 2, 3):
self.valveEntries.append(
LabelEntry(valvesbox,
1,
2 * valve,
" --> Valve " + str(valve) + ": ",
width=2))
self.entries = [self.rate, self.nCycles] + self.valveEntries
def assign_steps(routes):
for route in routes['routes']:
for leg in route['legs']:
for step in leg['steps']:
distance = step['distance']['value']
duration = step['duration']['value']
latitude = step['end_location']['lat']
longitude = step['end_location']['lng']
s = Step(distance, duration, latitude, longitude)
steps.append(s)
def run(self, cleanup=None, iter=None):
valves = []
states = []
for j in range(len(self.Valve.saved)):
i = iter
if self.Valve.expression:
valves.append(eval(self.Valve.saved[j], {}, {'i': i}))
else:
valves.append(int(self.Valve.saved[j]))
if self.State.expression:
states.append(eval(self.State.saved[j], {}, {'i': i}))
else:
states.append(int(self.State.saved[j]))
if states[-1] == 1:
Step.btndict[valves[-1]].config(bg="green")
else: # the saved state is 0
Step.btndict[valves[-1]].config(bg="gray")
self.setValves(valves, states)
Step.pause(self, 0)
self.checkIfCancel()
def run(self, iter=None, time=None):
i = iter
valves = []
for v in self.valveEntries:
if v.expression:
valves.append(eval(v.saved, {}, {'i': i}))
else:
valves.append(v.saved)
self.pump = self.specifyPump(valves[0], valves[1], valves[2])
ValveController.pPumps.remove(self.pump)
self.changeValveColor("Blue")
if self.nCycles.expression:
nCycles = eval(self.nCycles.saved, {}, {'i': i})
else:
nCycles = self.nCycles.saved
if self.rate.expression:
rate = eval(self.rate.saved, {}, {'i': i})
else:
rate = self.rate.saved
self.pump.forward(rate, nCycles)
if nCycles == -1:
Step.pause(self, float('Inf'), cleanup=self.cleanup)
else:
Step.pause(self,
float(nCycles) / float(rate),
cleanup=self.cleanup)
Step.pause(self, time, cleanup=self.cleanup)
self.changeValveColor("gray")
def put_step(self, command):
#PutStep <name> <description> <cost_in_hours> <name_of_goal>
elements = command.split()
goal_name = elements[1].lower()
name = elements[2].lower()
description = ""
cost = int(elements[3])
step = Step.build_new_step(name, description, cost)
# Find the goal in life and add this step to it.
success = False
for goal in self.life.get_goals():
if goal.name == goal_name:
goal.put_step(step)
success = True
if success == False:
print "Specified goal not found!"
def InsertRows(self, pos, numRows=1):
if (pos == -1):
pos = 0
newPos = pos + 1
if (self.steps.size() == 0):
lastLabel = 0
else:
lastLabel = pos
newLabel = lastLabel + 1
try:
self.steps.append(Step())
except ARM.ARMException, errorText:
dlg = wx.MessageDialog(self.GetView(), str(errorText), 'Add Step',
wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return
def __update_raw_tests(self):
self.raw_test.scenarios.append(
Scenario(url=self.url,
feature_name=self.feature_name,
text="Example test scenario"))
for choice in self.cases[0].selected_expands:
self.raw_test.scenarios[0].steps.append(
Step(step_type=choice.parent.step_type,
feature_name=self.feature_name,
x_path=choice.parent.xpath,
input_type=choice.parent.input_type,
cases=[],
label="Element " + choice.parent.name +
" has value <choice{}>".format(choice.parent.id)))
for case in self.cases:
for i, choice in enumerate(case.selected_expands):
self.raw_test.scenarios[0].steps[i].cases.append(choice.choice)
def pipeline_from_config_file(config_file):
"""
Create a Pipeline instance from a ConfigObj/INI configuration file
`config_file` which specifies the Pipeline steps, data directories
etc.
"""
# Do we have a spec file? If so, do parameter and input/output key
# validation as well. If not keep going.
spec_file = utilities.find_spec_file(Pipeline)
# Now do the actual parsing and, if we do have a spec file, validate as
# well.
parsed = config_parser.loads(config_file,
specfile=spec_file)['pipeline']
# Create a Pipeline instance with no steps, we will add them later.
pipe = Pipeline(name=parsed['name'],
system=parsed['system'],
log_level=parsed.get('log_level', DEFAULT_LOG_LEVEL),
local_logs=parsed.get('local_log_mode', DEFAULT_LOCAL_LOGS))
# The only thing that requires special handling is the steps array.
# Here we have to create Step instances of the appropriate class and
# pass the appropriate Step config file to them.
# Also, as part of the "steps" list, we have hints on which data each
# Step produces and which data it consumes. In order to transfer these
# pieces of data in-memory between steps we have a simple architecture.
# We have a dictionary at the Pipeline level where data is put and
# possibly updated. This is the clipboard. Then before executing each
# Step, the data the Step needs in input is put in Step.inbox which
# is a list. Elements are put in that list in the order they are defined
# in that Step section of the Pipeline configuration file (inbox
# parameter). After the Step completes, data from Step.outbox is
# fetched and put in the clipboard. Data in Step.outbox is assumed to
# be in the order defined in that Step section of the Pipeline
# configuration file (outbox parameter).
steps = [Step.from_parsed_config(x, pipe) for x in parsed['steps']]
# Finally update the pipe.steps list. We did this so that the Step
# instances could make use in their initialization, of whatever they
# needed to pull from the Pipeline object they belong to.
pipe.configure(steps)
return(pipe)
def pipeline_from_config_file(config_file):
"""
Create a Pipeline instance from a ConfigObj/INI configuration file
`config_file` which specifies the Pipeline steps, data directories
etc.
"""
# Do we have a spec file? If so, do parameter and input/output key
# validation as well. If not keep going.
spec_file = utilities.find_spec_file(Pipeline)
# Now do the actual parsing and, if we do have a spec file, validate as
# well.
parsed = config_parser.loads(config_file, specfile=spec_file)['pipeline']
# Create a Pipeline instance with no steps, we will add them later.
pipe = Pipeline(name=parsed['name'],
system=parsed['system'],
log_level=parsed.get('log_level', DEFAULT_LOG_LEVEL),
local_logs=parsed.get('local_log_mode',
DEFAULT_LOCAL_LOGS))
# The only thing that requires special handling is the steps array.
# Here we have to create Step instances of the appropriate class and
# pass the appropriate Step config file to them.
# Also, as part of the "steps" list, we have hints on which data each
# Step produces and which data it consumes. In order to transfer these
# pieces of data in-memory between steps we have a simple architecture.
# We have a dictionary at the Pipeline level where data is put and
# possibly updated. This is the clipboard. Then before executing each
# Step, the data the Step needs in input is put in Step.inbox which
# is a list. Elements are put in that list in the order they are defined
# in that Step section of the Pipeline configuration file (inbox
# parameter). After the Step completes, data from Step.outbox is
# fetched and put in the clipboard. Data in Step.outbox is assumed to
# be in the order defined in that Step section of the Pipeline
# configuration file (outbox parameter).
steps = [Step.from_parsed_config(x, pipe) for x in parsed['steps']]
# Finally update the pipe.steps list. We did this so that the Step
# instances could make use in their initialization, of whatever they
# needed to pull from the Pipeline object they belong to.
pipe.configure(steps)
return (pipe)
def scrape_page(page_link):
page_reponse = requests.get(page_link)
page_soup = BeautifulSoup(page_reponse.text, "html.parser")
try:
image_url = page_soup.select_one(
".recipeGallerySegment .bigImg img")['src']
if "without-watermark" not in image_url:
global recipes_with_watermarks
recipes_with_watermarks += 1
return
recipe_title = page_soup.select_one(
".recipeTitleSegment h1").text.strip()
before_split = page_soup.select_one(".method .info .info").text.strip()
recipe_preparation_time = int(re.findall("\d+", before_split)[0])
if "min" in before_split:
recipe_preparation_time = int(60 * recipe_preparation_time)
elif "val" in before_split:
recipe_preparation_time = int(60 * 60 * recipe_preparation_time)
recipe_portion_amount = page_soup.select_one(".info").text.strip()
if len(recipe_portion_amount) is 0:
recipe_portion_amount = int(4)
else:
recipe_portion_amount = int(
re.findall("\d+", recipe_portion_amount)[0])
recipe_description = ''
try:
recipe_description = page_soup.select_one(
".authorsDescription").text.strip()
except AttributeError:
recipe_description = ''
print('No description')
amounts = page_soup.select(".ingredients .infoA table tr")
recipe_products = []
for amount in amounts:
cells = amount.select("td")
if len(cells) is 1:
continue
quantity = cells[0].text.strip()
product_name = cells[1].text.strip()[0:30].strip()
new_product = Product(product_name, quantity)
recipe_products.append(new_product.__dict__)
steps = page_soup.select(".infoA .description")
recipe_steps = []
for step in steps:
step_text = step.select_one(".text")
# print(step_text.text)
new_step = Step(step_text.text)
recipe_steps.append(new_step.__dict__)
recipe_view_count = int(0)
recipe_rating = int(0)
recipe_votes_count = int(0)
image_extension = image_url.split('.')[-1]
image_fileName = ''
image_name = ''
while True:
image_name = uuid.uuid4().hex
image_fileName = image_name + "." + image_extension
if not os.path.isfile("Photos/" + image_fileName):
break
opener = urllib.request.URLopener()
opener.addheader(
'User-Agent',
'Mozilla/5.0 (iPad; U; CPU OS 3_2_1 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Mobile/7B405'
)
opener.retrieve(image_url, "Photos/" + image_fileName)
# urllib.request.urlretrieve(image_url, "Photos/" + image_fileName)
recipe_image = Photo(image_fileName)
recipe_images = []
recipe_images.append(recipe_image.__dict__)
# Tags
recipe_tags = []
temp = Tag("grilio patiekalai")
recipe_tags.append(temp.__dict__)
tags = page_soup.select(".guidelinesSegment a")
for tag in tags:
if not "lamaistas" in tag.text:
new_tag = Tag(tag.text)
recipe_tags.append(new_tag.__dict__)
new_recipe = Recipe(recipe_title, recipe_products, recipe_steps,
recipe_portion_amount, recipe_preparation_time,
recipe_description, recipe_view_count,
recipe_rating, recipe_votes_count, recipe_images,
recipe_tags)
new_recipes.append(new_recipe.__dict__)
print("Saved " + page_link + " " + str(len(new_recipes)))
except Exception as e:
print("Error " + str(e) + " || " + page_link)
def setUp(self):
self.root = Step(None, (0, 0), "O")
self.leaf1 = self.root.add_leaf(1, ".")
self.leaf11 = self.leaf1.add_leaf(1, ".")
self.leaf113 = self.leaf11.add_leaf(3, ".")
self.leaf1132 = self.leaf113.add_leaf(2, ".")
def saveEntries(self, type="int", iters=None):
rate = self.rate.get()
cycles = self.nCycles.get()
# Check if valve entries are ok for all loop iterations.
valves = []
allInt = True
for v in self.valveEntries:
v0 = v.get()
valves.append(v0)
try:
v1 = int(v0)
if v1 not in self.btndict:
raise ValueError(
v0 +
" in pump step is not a valid valve. Valid valves are "
+ self.btndict["AvailablePinsStatement"] + ".")
v.expression = False
except:
if not iters:
raise ValueError(
v0 +
" in pump step is not a valid valve. Valid valves are "
+ self.btndict["AvailablePinsStatement"] + ".")
else: #check if valid expression fo valve
self.recursiveIterCheck(iters, v0,
self.checkValidValveEntry, ())
v.expression = True
allInt = False
if allInt:
if len(set(valves)) < 3:
raise ValueError("There are duplicate valve entries")
else:
self.recursiveIterCheck(iters, valves, self.checkDuplicateValves,
())
try:
rate1 = int(rate)
if rate1 < 0:
raise ValueError(
rate +
" is not a valid rate for a pump step. Rates must be positive integers."
)
self.rate.expression = False
except:
if not iters:
raise ValueError(
rate +
" is not a valid rate for a pump step. Rates must be positive integers."
)
else: #check if valid expression.
self.recursiveIterCheck(iters, rate, self.checkValidRate, ())
self.rate.expression = True
try:
try:
cycles1 = int(cycles)
except:
if not iters:
raise ValueError(
cycles +
" is not a valid number of cycles for a pump step. The number of cycles must"
" be either a positive integer or -1 to pump indefinitely until interupted."
)
else: # check if valid expression
self.recursiveIterCheck(iters, cycles,
self.checkValidCycles, ())
self.nCycles.expression = True
Step.saveEntries(self, type="int", iters=iters)
return
if cycles1 == -1:
if iters:
raise ValueError(
"Pump steps can pump indefinitely only if they"
" are the final step in a protocol.")
else:
if hasattr(self, 'last') and not self.last:
raise ValueError(
"Pump steps can pump indefinitely only if they"
" are the final step in a protocol.")
if cycles1 < -1:
if iters:
raise ValueError(
cycles +
" is not a valid number of cycles for a pump step. The number of cycles must be"
" a positive integer.")
else:
raise ValueError(
cycles +
" is not a valid number of cycles for a pump step. The number of cycles must be"
" a positive integer, or -1 on the final step of a protocol to pump indefinitely."
)
self.nCycles.expression = False
except ValueError as E:
raise E
Step.saveEntries(self, type="int", iters=iters)
def plan_journey(self, from_location, to_station, time, departure):
base_url = "journeys?lang=nl-NL&"
time = "dateTime=" + time
from_station = "&from=" + from_location
to_station = "&to=" + to_station
before = "&before=1"
after = "&after=5"
sequence = "&sequence=1"
options = "&byFerry=true&bySubway=true&byBus=true&byTram=true&byTrain=true"
search_type = "&searchType=" + departure
url = self.url + base_url + time + from_station + to_station + before + after + sequence + options + search_type
journeys = requests.get(url).json()
print(url)
steps = []
first = True
counter = 1
destination_temp = ""
end_time_temp = ""
for part in journeys['journeys'][1]['legs']:
last_stop = part['stops'][-1]['location']
first_stop = part['stops'][0]['location']
step = Step()
if part['type'] == "continuous":
if first:
step.kind = part['mode']['name'][0:5]
step.departure_location = first_stop['name']
if 'stopType' in last_stop:
step.arrival_location = last_stop[
'stopType'] + " " + last_stop['place'][
'name'] + last_stop['name']
else:
step.arrival_location = last_stop['place'][
'name'] + " " + last_stop['stationType']
step.departure_time = journeys['journeys'][1]['departure']
step.arrival_time = self.calculate_end_time(
journeys['journeys'][1]['departure'], part['duration'])
step.duration = part['duration']
elif counter == len(journeys['journeys'][1]['legs']):
step.kind = part['mode']['name'][0:5]
step.departure_location = destination_temp
step.arrival_location = last_stop['place'][
'name'] + " " + last_stop['name']
step.departure_time = end_time_temp
step.arrival_time = journeys['journeys'][1]['arrival']
step.duration = part['duration']
else:
step.kind = part['mode']['name'][0:5]
step.departure_location = destination_temp
if 'stopType' in last_stop:
step.arrival_location = last_stop['place'][
'name'] + " " + last_stop['stopType']
else:
step.arrival_location = last_stop['place'][
'name'] + " " + last_stop['stationType']
step.departure_time = end_time_temp
step.arrival_time = self.calculate_end_time(
end_time_temp, part['duration'])
step.duration = part['duration']
else:
end_time_temp = part['stops'][-1]['arrival']
if part['mode']['type'] == 'train':
destination_temp = last_stop[
'stationType'] + " " + last_stop['name']
step.kind = part['mode']['name'] + " richting " + part[
'destination']
step.departure_location = first_stop[
'stationType'] + " " + first_stop['name']
step.arrival_location = last_stop[
'stationType'] + " " + last_stop['name']
step.departure_time = part['stops'][0]['departure']
step.arrival_time = part['stops'][-1]['arrival']
step.duration = self.calculate_duration(
part['stops'][-1]['arrival'],
part['stops'][0]['departure'])
else:
destination_temp = last_stop['stopType'] + " " + last_stop[
'place']['name'] + " " + last_stop['name']
step.kind = part['mode']['name'] + " richting " + part[
'destination']
step.departure_location = first_stop[
'stopType'] + " " + first_stop['place'][
'name'] + " " + first_stop['name']
step.arrival_location = last_stop[
'stopType'] + " " + last_stop['place'][
'name'] + " " + last_stop['name']
step.departure_time = part['stops'][0]['departure']
step.arrival_time = part['stops'][-1]['arrival']
step.duration = self.calculate_duration(
part['stops'][-1]['arrival'],
part['stops'][0]['departure'])
steps.append(step)
counter += 1
first = False
return steps
class UsabilityContentHandler(ContentHandler,EntityResolver):
def __init__(self):
self.thePersonas = []
self.theExternalDocuments = []
self.theDocumentReferences = []
self.theConceptReferences = []
self.thePersonaCharacteristics = []
self.theTaskCharacteristics = []
self.theTasks = []
self.theUseCases = []
b = Borg()
self.configDir = b.configDir
self.resetPersonaAttributes()
self.resetDocumentReferenceAttributes()
self.resetConceptReferenceAttributes()
self.resetPersonaCharacteristicAttributes()
self.resetTaskCharacteristicAttributes()
self.resetTaskAttributes()
self.resetUseCaseAttributes()
def resolveEntity(self,publicId,systemId):
return self.configDir + '/usability.dtd'
def personas(self):
return self.thePersonas
def externalDocuments(self):
return self.theExternalDocuments
def documentReferences(self):
return self.theDocumentReferences
def conceptReferences(self):
return self.theConceptReferences
def personaCharacteristics(self):
return self.thePersonaCharacteristics
def taskCharacteristics(self):
return self.theTaskCharacteristics
def tasks(self):
return self.theTasks
def usecases(self):
return self.theUseCases
def resetPersonaAttributes(self):
self.inActivities = 0
self.inAttitudes = 0
self.inAptitudes = 0
self.inMotivations = 0
self.inSkills = 0
self.inIntrinsic = 0
self.inContextual = 0
self.theName = ''
self.theTags = []
self.theType = ''
self.theImage = ''
self.isAssumptionPersona = False
self.theActivities = ''
self.theAptitudes = ''
self.theMotivations = ''
self.theSkills = ''
self.theIntrinsic = ''
self.theContextual = ''
self.theEnvironmentProperties = []
self.resetPersonaEnvironmentAttributes()
def resetPersonaEnvironmentAttributes(self):
self.theEnvironmentName = ''
self.theRoles = []
self.isDirect = True
self.inNarrative = 0
self.theNarrative = ''
def resetExternalDocumentAttributes(self):
self.theName = ''
self.theVersion = ''
self.theDate = ''
self.theAuthors = ''
self.inDescription = 0
self.theDescription = ''
def resetDocumentReferenceAttributes(self):
self.inExcerpt = 0
self.theName = ''
self.theContributor = ''
self.theDocument = ''
self.theExcerpt = ''
def resetConceptReferenceAttributes(self):
self.inDescription = 0
self.theName = ''
self.theConcept = ''
self.theObject = ''
self.theDescription = ''
def resetPersonaCharacteristicAttributes(self):
self.thePersona = ''
self.theBvName = ''
self.theModalQualifier = ''
self.inDefinition = 0
self.theDefinition = ''
self.theGrounds = []
self.theWarrants = []
self.theRebuttals = []
def resetTaskCharacteristicAttributes(self):
self.theTask = ''
self.theModalQualifier = ''
self.inDefinition = 0
self.theDefinition = ''
self.theGrounds = []
self.theWarrants = []
self.theRebuttals = []
def resetTaskAttributes(self):
self.theName = ''
self.theTags = []
self.theCode = ''
self.theAuthor = ''
self.isAssumptionTask = False
self.inObjective = 0
self.theObjective = ''
self.theEnvironmentProperties = []
self.resetTaskEnvironmentAttributes()
def resetTaskEnvironmentAttributes(self):
self.theEnvironmentName = ''
self.inDependencies = 0
self.inNarrative = 0
self.inConsequences = 0
self.inBenefits = 0
self.theDependencies = ''
self.theNarrative = ''
self.theConsequences = ''
self.theBenefits = ''
self.theTaskPersonas = []
self.theConcerns = []
self.theConcernAssociations = []
def resetUseCaseAttributes(self):
self.theName = ''
self.theTags = []
self.theAuthor = ''
self.theCode = ''
self.inDescription = 0
self.theDescription = ''
self.theActors = []
self.theEnvironmentProperties = []
self.resetUseCaseEnvironmentAttributes()
def resetUseCaseEnvironmentAttributes(self):
self.theEnvironmentName = ''
self.inPreconditions = 0
self.thePreconditions = ''
self.inPostconditions = 0
self.thePostconditions = ''
self.theSteps = Steps()
self.theCurrentStep = None
self.theCurrentStepNo = 0
self.theExcName = ''
self.theExcType = ''
self.theExcValue = ''
self.theExcCat = ''
self.inDefinition = 0
self.theDefinition = ''
def startElement(self,name,attrs):
self.currentElementName = name
if name == 'persona':
self.theName = attrs['name']
self.theType = attrs['type']
self.theImage = attrs['image']
if (attrs['assumption_persona'] == 'TRUE'):
self.isAssumptionPersona = True
elif name == 'persona_environment':
self.theEnvironmentName = attrs['name']
if (attrs['is_direct'] == 'FALSE'):
self.isDirect = False
elif name == 'persona_role':
self.theRoles.append(attrs['name'])
elif name == 'external_document':
self.theName = attrs['name']
self.theVersion = attrs['version']
self.theDate = attrs['date']
self.theAuthors = attrs['authors']
elif name == 'document_reference':
self.theName = attrs['name']
self.theContributor = attrs['contributor']
self.theDocument = attrs['document']
elif name == 'concept_reference':
self.theName = attrs['name']
self.theConcept = attrs['concept']
self.theObject = attrs['object']
elif name == 'persona_characteristic':
self.thePersona = attrs['persona']
self.theBvName = u2s(attrs['behavioural_variable'])
self.theModalQualifier = attrs['modal_qualifier']
elif name == 'task_characteristic':
self.theTask = attrs['task']
self.theModalQualifier = attrs['modal_qualifier']
elif name == 'grounds':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theGrounds.append((refName,'',refType))
elif name == 'warrant':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theWarrants.append((refName,'',refType))
elif name == 'rebuttal':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theRebuttals.append((refName,'',refType))
elif name == 'task':
self.theName = attrs['name']
try:
self.theCode = attrs['code']
except KeyError:
self.theCode = ''
self.theAuthor = attrs['author']
if (attrs['assumption_task'] == 'TRUE'):
self.isAssumptionTask = True
elif name == 'task_environment':
self.theEnvironmentName = attrs['name']
elif name == 'task_persona':
self.theTaskPersonas.append((attrs['persona'],durationValue(attrs['duration']),frequencyValue(attrs['frequency']),attrs['demands'],attrs['goal_conflict']))
elif name == 'task_concern':
self.theConcerns.append(attrs['asset'])
elif name == 'task_concern_association':
self.theConcernAssociations.append((attrs['source_name'],a2s(attrs['source_nry']),attrs['link_name'],attrs['target_name'],a2s(attrs['target_nry'])))
elif name == 'usecase':
self.theName = attrs['name']
self.theAuthor = attrs['author']
self.theCode = attrs['code']
elif name == 'actor':
self.theActors.append(attrs['name'])
elif name == 'usecase_environment':
self.theEnvironmentName = attrs['name']
elif name == 'step':
self.theCurrentStepNo = attrs['number']
self.theCurrentStep = Step(attrs['description'])
elif name == 'exception':
self.theExcName = attrs['name']
self.theExcType = attrs['type']
self.theExcValue = attrs['value']
self.theExcCat = u2s(attrs['category'])
elif name == 'activities':
self.inActivities = 1
self.theActivities = ''
elif name == 'attitudes':
self.inAttitudes = 1
self.theAttitudes = ''
elif name == 'aptitudes':
self.inAptitudes = 1
self.theAptitudes = ''
elif name == 'motivations':
self.inMotivations = 1
self.theMotivations = ''
elif name == 'skills':
self.inSkills = 1
self.theSkills = ''
elif name == 'intrinsic':
self.inIntrinsic = 1
self.theIntrinsic = ''
elif name == 'contextual':
self.inContextual = 1
self.theContextual = ''
elif name == 'narrative':
self.inNarrative = 1
self.theNarrative = ''
elif name == 'consequences':
self.inConsequences = 1
self.theConsequences = ''
elif name == 'benefits':
self.inBenefits = 1
self.theBenefits = ''
elif name == 'excerpt':
self.inExcerpt = 1
self.theExcerpt = ''
elif name == 'description':
self.inDescription = 1
self.theDescription = ''
elif name == 'definition':
self.inDefinition = 1
self.theDefinition = ''
elif name == 'dependencies':
self.inDependencies = 1
self.theDependencies = ''
elif name == 'objective':
self.inObjective = 1
self.theObjective = ''
elif name == 'preconditions':
self.inPreconditions = 1
self.thePreconditions = ''
elif name == 'postconditions':
self.inPostconditions = 1
self.thePostconditions = ''
elif name == 'tag':
self.theTags.append(attrs['name'])
def characters(self,data):
if self.inActivities:
self.theActivities += data
elif self.inAttitudes:
self.theAttitudes += data
elif self.inAptitudes:
self.theAptitudes += data
elif self.inMotivations:
self.theMotivations += data
elif self.inSkills:
self.theSkills += data
elif self.inIntrinsic:
self.theIntrinsic += data
elif self.inContextual:
self.theContextual += data
elif self.inConsequences:
self.theConsequences += data
elif self.inBenefits:
self.theBenefits += data
elif self.inExcerpt:
self.theExcerpt += data
elif self.inDescription:
self.theDescription += data
elif self.inDefinition:
self.theDefinition += data
elif self.inDependencies:
self.theDependencies += data
elif self.inObjective:
self.theObjective += data
elif self.inPreconditions:
self.thePreconditions += data
elif self.inPostconditions:
self.thePostconditions += data
elif self.inNarrative:
self.theNarrative += data
def endElement(self,name):
if name == 'persona':
p = PersonaParameters(self.theName,self.theActivities,self.theAttitudes,self.theAptitudes,self.theMotivations,self.theSkills,self.theIntrinsic,self.theContextual,self.theImage,self.isAssumptionPersona,self.theType,self.theTags,self.theEnvironmentProperties,{})
self.thePersonas.append(p)
self.resetPersonaAttributes()
elif name == 'persona_environment':
p = PersonaEnvironmentProperties(self.theEnvironmentName,self.isDirect,self.theNarrative,self.theRoles,{'narrative':{}})
self.theEnvironmentProperties.append(p)
self.resetPersonaEnvironmentAttributes()
elif name == 'external_document':
p = ExternalDocumentParameters(self.theName,self.theVersion,self.theDate,self.theAuthors,self.theDescription)
self.theExternalDocuments.append(p)
self.resetExternalDocumentAttributes()
elif name == 'document_reference':
p = DocumentReferenceParameters(self.theName,self.theDocument,self.theContributor,self.theExcerpt)
self.theDocumentReferences.append(p)
self.resetDocumentReferenceAttributes()
elif name == 'concept_reference':
p = ConceptReferenceParameters(self.theName,self.theConcept,self.theObject,self.theDescription)
self.theConceptReferences.append(p)
self.resetConceptReferenceAttributes()
elif name == 'persona_characteristic':
p = PersonaCharacteristicParameters(self.thePersona,self.theModalQualifier,self.theBvName,self.theDefinition,self.theGrounds,self.theWarrants,[],self.theRebuttals)
self.thePersonaCharacteristics.append(p)
self.resetPersonaCharacteristicAttributes()
elif name == 'task_characteristic':
p = TaskCharacteristicParameters(self.theTask,self.theModalQualifier,self.theDefinition,self.theGrounds,self.theWarrants,[],self.theRebuttals)
self.theTaskCharacteristics.append(p)
self.resetTaskCharacteristicAttributes()
elif name == 'task':
p = TaskParameters(self.theName,self.theCode,self.theObjective,self.isAssumptionTask,self.theAuthor,self.theTags,self.theEnvironmentProperties)
self.theTasks.append(p)
self.resetTaskAttributes()
elif name == 'task_environment':
p = TaskEnvironmentProperties(self.theEnvironmentName,self.theDependencies,self.theTaskPersonas,self.theConcerns,self.theConcernAssociations,self.theNarrative,self.theConsequences,self.theBenefits,{'narrative':{},'consequences':{},'benefits':{}})
self.theEnvironmentProperties.append(p)
self.resetTaskEnvironmentAttributes()
elif name == 'exception':
self.theCurrentStep.addException((self.theExcName,self.theExcType,self.theExcValue,self.theExcCat,self.theDefinition))
elif name == 'step':
self.theCurrentStep.setTags(self.theTags)
self.theSteps.append(self.theCurrentStep)
self.theCurrentStep = None
elif name == 'usecase_environment':
p = UseCaseEnvironmentProperties(self.theEnvironmentName,self.thePreconditions,self.theSteps,self.thePostconditions)
self.theEnvironmentProperties.append(p)
self.resetUseCaseEnvironmentAttributes()
elif name == 'usecase':
p = UseCaseParameters(self.theName,self.theAuthor,self.theCode,self.theActors,self.theDescription,self.theTags,self.theEnvironmentProperties)
self.theUseCases.append(p)
self.resetUseCaseAttributes()
elif name == 'activities':
self.inActivities = 0
elif name == 'attitudes':
self.inAttitudes = 0
elif name == 'aptitudes':
self.inAptitudes = 0
elif name == 'motivations':
self.inMotivations = 0
elif name == 'skills':
self.inSkills = 0
elif name == 'intrinsic':
self.inIntrinsic = 0
elif name == 'contextual':
self.inContextual = 0
elif name == 'narrative':
self.inNarrative = 0
elif name == 'excerpt':
self.inExcerpt = 0
elif name == 'description':
self.inDescription = 0
elif name == 'definition':
self.inDefinition = 0
elif name == 'dependencies':
self.inDependencies = 0
elif name == 'objective':
self.inObjective = 0
elif name == 'preconditions':
self.inPreconditions = 0
elif name == 'postconditions':
self.inPostconditions = 0
elif name == 'benefits':
self.inBenefits = 0
elif name == 'consequences':
self.inConsequences = 0
def gen_random_path(self, duration, cachedPrefixes=None):
# Since when initilize a module, all its local variables
# have been initilized
if not self.commPrepared:
self.prepareCommands()
self.commPrepared = True
path = list()
timeSum = 0.0
passedTime = 0.0
while timeSum < duration:
# get enabled commands list
variables = [var.getValue() for _, var in self.localVars.items()]
varsStr = ''.join([str(v) for v in variables])
if len(self.scDict) == 0:
# 由于存在unbounded变量,无法提前判断所有的变量组合的enabled commands
# 因此需要手工判断
cmd_probs = []
for _,module in self.modules.items():
for _,comm in module.allCommands().items():
if comm.guard(self.localVars, self.constants):
cmd_probs.append((comm, comm.prob()))
else:
cmd_probs = self.scDict[varsStr]
if len(cmd_probs) == 0:
path.append(self.step_of_current(passedTime=passedTime))
self.restoreSystem()
return None, path
transition, holdingTime, rate, biasingRate, exitRate, biasingExitRate = self.nextState(
cmd_probs, duration=duration - timeSum)
timeSum += holdingTime
if len(path) == 0 and holdingTime > duration:
# The first transition is not possible to happen within the given duration
# In this situation, we think that the transition not made.
# return the path: [Step(initState, emptyTransition)]
# self._updateCurAndPrevState()
step = self.step_of_current()
path.append(step)
self.restoreSystem()
return (None, path)
if timeSum > duration:
holdingTime -= (timeSum - duration)
step = Step(
self.prevState.stateId,
self.prevState.apSet.copy(),
holdingTime,
passedTime,
transition,
rate,
biasingRate,
exitRate,
biasingExitRate)
path.append(step)
passedTime += holdingTime
if len(path) >= 1 and self.stopCondition and self.stopCondition(
self.localVars, self.constants):
# add this empty step (with no transition made)
# to represent the state the system currently is in.
path.append(self.step_of_current(passedTime=passedTime))
self.restoreSystem()
return (None, path)
# MUST be executed before the function returns
# to prepare generating next random path.
self.restoreSystem()
return None, path
def __init__(self, initial_state: State):
self.steps = [Step(None, None, initial_state)]
def startElement(self,name,attrs):
self.currentElementName = name
if name == 'persona':
self.theName = attrs['name']
self.theType = attrs['type']
self.theImage = attrs['image']
if (attrs['assumption_persona'] == 'TRUE'):
self.isAssumptionPersona = True
elif name == 'persona_environment':
self.theEnvironmentName = attrs['name']
if (attrs['is_direct'] == 'FALSE'):
self.isDirect = False
elif name == 'persona_role':
self.theRoles.append(attrs['name'])
elif name == 'external_document':
self.theName = attrs['name']
self.theVersion = attrs['version']
self.theDate = attrs['date']
self.theAuthors = attrs['authors']
elif name == 'document_reference':
self.theName = attrs['name']
self.theContributor = attrs['contributor']
self.theDocument = attrs['document']
elif name == 'concept_reference':
self.theName = attrs['name']
self.theConcept = attrs['concept']
self.theObject = attrs['object']
elif name == 'persona_characteristic':
self.thePersona = attrs['persona']
self.theBvName = u2s(attrs['behavioural_variable'])
self.theModalQualifier = attrs['modal_qualifier']
elif name == 'task_characteristic':
self.theTask = attrs['task']
self.theModalQualifier = attrs['modal_qualifier']
elif name == 'grounds':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theGrounds.append((refName,'',refType))
elif name == 'warrant':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theWarrants.append((refName,'',refType))
elif name == 'rebuttal':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theRebuttals.append((refName,'',refType))
elif name == 'task':
self.theName = attrs['name']
try:
self.theCode = attrs['code']
except KeyError:
self.theCode = ''
self.theAuthor = attrs['author']
if (attrs['assumption_task'] == 'TRUE'):
self.isAssumptionTask = True
elif name == 'task_environment':
self.theEnvironmentName = attrs['name']
elif name == 'task_persona':
self.theTaskPersonas.append((attrs['persona'],durationValue(attrs['duration']),frequencyValue(attrs['frequency']),attrs['demands'],attrs['goal_conflict']))
elif name == 'task_concern':
self.theConcerns.append(attrs['asset'])
elif name == 'task_concern_association':
self.theConcernAssociations.append((attrs['source_name'],a2s(attrs['source_nry']),attrs['link_name'],attrs['target_name'],a2s(attrs['target_nry'])))
elif name == 'usecase':
self.theName = attrs['name']
self.theAuthor = attrs['author']
self.theCode = attrs['code']
elif name == 'actor':
self.theActors.append(attrs['name'])
elif name == 'usecase_environment':
self.theEnvironmentName = attrs['name']
elif name == 'step':
self.theCurrentStepNo = attrs['number']
self.theCurrentStep = Step(attrs['description'])
elif name == 'exception':
self.theExcName = attrs['name']
self.theExcType = attrs['type']
self.theExcValue = attrs['value']
self.theExcCat = u2s(attrs['category'])
elif name == 'activities':
self.inActivities = 1
self.theActivities = ''
elif name == 'attitudes':
self.inAttitudes = 1
self.theAttitudes = ''
elif name == 'aptitudes':
self.inAptitudes = 1
self.theAptitudes = ''
elif name == 'motivations':
self.inMotivations = 1
self.theMotivations = ''
elif name == 'skills':
self.inSkills = 1
self.theSkills = ''
elif name == 'intrinsic':
self.inIntrinsic = 1
self.theIntrinsic = ''
elif name == 'contextual':
self.inContextual = 1
self.theContextual = ''
elif name == 'narrative':
self.inNarrative = 1
self.theNarrative = ''
elif name == 'consequences':
self.inConsequences = 1
self.theConsequences = ''
elif name == 'benefits':
self.inBenefits = 1
self.theBenefits = ''
elif name == 'excerpt':
self.inExcerpt = 1
self.theExcerpt = ''
elif name == 'description':
self.inDescription = 1
self.theDescription = ''
elif name == 'definition':
self.inDefinition = 1
self.theDefinition = ''
elif name == 'dependencies':
self.inDependencies = 1
self.theDependencies = ''
elif name == 'objective':
self.inObjective = 1
self.theObjective = ''
elif name == 'preconditions':
self.inPreconditions = 1
self.thePreconditions = ''
elif name == 'postconditions':
self.inPostconditions = 1
self.thePostconditions = ''
elif name == 'tag':
self.theTags.append(attrs['name'])
def add_step(self, action: int, reward: float, new_state: State):
self.steps.append(Step(action, reward, new_state))
import Processor
from Step import Step
with open('input.txt') as f:
common_code = f.readline().strip().split(',')
computer = Processor.Processor(common_code, 0)
computer.reset()
step_tree = Step(None, (0, 0), 'O')
direction_map = [None, 2, 1, 4, 3]
def withdraw(direction):
while True:
try:
computer.run()
except Processor.ProcessorInputException:
computer.push_input(direction_map[direction])
except Processor.ProcessorOutputException:
return
def do_step(upstream, direction):
while True:
try:
computer.run()
except Processor.ProcessorInputException:
computer.push_input(direction)
except Processor.ProcessorOutputException:
result = computer.read_output()
import Processor
from Step import Step
with open('input.txt') as f:
common_code = f.readline().strip().split(',')
computer = Processor.Processor(common_code, 0)
computer.reset()
step_tree = Step(None, (0, 0), 'O')
direction_map = [None, 2, 1, 4, 3]
oxygen_coords = (None, None)
def withdraw(direction):
while True:
try:
computer.run()
except Processor.ProcessorInputException:
computer.push_input(direction_map[direction])
except Processor.ProcessorOutputException:
return
def do_step(upstream, direction):
global oxygen_coords
while True:
try:
computer.run()
except Processor.ProcessorInputException:
computer.push_input(direction)
def startElement(self, name, attrs):
self.currentElementName = name
if name == 'persona':
self.theName = attrs['name']
self.theType = attrs['type']
self.theImage = attrs['image']
if (attrs['assumption_persona'] == 'TRUE'):
self.isAssumptionPersona = True
elif name == 'persona_environment':
self.theEnvironmentName = attrs['name']
if (attrs['is_direct'] == 'FALSE'):
self.isDirect = False
elif name == 'persona_role':
self.theRoles.append(attrs['name'])
elif name == 'external_document':
self.theName = attrs['name']
self.theVersion = attrs['version']
self.theDate = attrs['date']
self.theAuthors = attrs['authors']
elif name == 'document_reference':
self.theName = attrs['name']
self.theContributor = attrs['contributor']
self.theDocument = attrs['document']
elif name == 'concept_reference':
self.theName = attrs['name']
self.theConcept = attrs['concept']
self.theObject = attrs['object']
elif name == 'persona_characteristic':
self.thePersona = attrs['persona']
self.theBvName = u2s(attrs['behavioural_variable'])
self.theModalQualifier = attrs['modal_qualifier']
elif name == 'task_characteristic':
self.theTask = attrs['task']
self.theModalQualifier = attrs['modal_qualifier']
elif name == 'grounds':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theGrounds.append((refName, '', refType))
elif name == 'warrant':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theWarrants.append((refName, '', refType))
elif name == 'rebuttal':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theRebuttals.append((refName, '', refType))
elif name == 'task':
self.theName = attrs['name']
try:
self.theCode = attrs['code']
except KeyError:
self.theCode = ''
self.theAuthor = attrs['author']
if (attrs['assumption_task'] == 'TRUE'):
self.isAssumptionTask = True
elif name == 'task_environment':
self.theEnvironmentName = attrs['name']
elif name == 'task_persona':
self.theTaskPersonas.append(
(attrs['persona'], durationValue(attrs['duration']),
frequencyValue(attrs['frequency']), attrs['demands'],
attrs['goal_conflict']))
elif name == 'task_concern':
self.theConcerns.append(attrs['asset'])
elif name == 'task_concern_association':
self.theConcernAssociations.append(
(attrs['source_name'], a2s(attrs['source_nry']),
attrs['link_name'], attrs['target_name'],
a2s(attrs['target_nry'])))
elif name == 'usecase':
self.theName = attrs['name']
self.theAuthor = attrs['author']
self.theCode = attrs['code']
elif name == 'actor':
self.theActors.append(attrs['name'])
elif name == 'usecase_environment':
self.theEnvironmentName = attrs['name']
elif name == 'step':
self.theCurrentStepNo = attrs['number']
self.theCurrentStep = Step(attrs['description'])
elif name == 'exception':
self.theExcName = attrs['name']
self.theExcType = attrs['type']
self.theExcValue = attrs['value']
self.theExcCat = u2s(attrs['category'])
elif name == 'activities':
self.inActivities = 1
self.theActivities = ''
elif name == 'attitudes':
self.inAttitudes = 1
self.theAttitudes = ''
elif name == 'aptitudes':
self.inAptitudes = 1
self.theAptitudes = ''
elif name == 'motivations':
self.inMotivations = 1
self.theMotivations = ''
elif name == 'skills':
self.inSkills = 1
self.theSkills = ''
elif name == 'intrinsic':
self.inIntrinsic = 1
self.theIntrinsic = ''
elif name == 'contextual':
self.inContextual = 1
self.theContextual = ''
elif name == 'narrative':
self.inNarrative = 1
self.theNarrative = ''
elif name == 'consequences':
self.inConsequences = 1
self.theConsequences = ''
elif name == 'benefits':
self.inBenefits = 1
self.theBenefits = ''
elif name == 'excerpt':
self.inExcerpt = 1
self.theExcerpt = ''
elif name == 'description':
self.inDescription = 1
self.theDescription = ''
elif name == 'definition':
self.inDefinition = 1
self.theDefinition = ''
elif name == 'dependencies':
self.inDependencies = 1
self.theDependencies = ''
elif name == 'objective':
self.inObjective = 1
self.theObjective = ''
elif name == 'preconditions':
self.inPreconditions = 1
self.thePreconditions = ''
elif name == 'postconditions':
self.inPostconditions = 1
self.thePostconditions = ''
elif name == 'tag':
self.theTags.append(attrs['name'])
class UsabilityContentHandler(ContentHandler, EntityResolver):
def __init__(self):
self.thePersonas = []
self.theExternalDocuments = []
self.theDocumentReferences = []
self.theConceptReferences = []
self.thePersonaCharacteristics = []
self.theTaskCharacteristics = []
self.theTasks = []
self.theUseCases = []
b = Borg()
self.configDir = b.configDir
self.resetPersonaAttributes()
self.resetDocumentReferenceAttributes()
self.resetConceptReferenceAttributes()
self.resetPersonaCharacteristicAttributes()
self.resetTaskCharacteristicAttributes()
self.resetTaskAttributes()
self.resetUseCaseAttributes()
def resolveEntity(self, publicId, systemId):
return self.configDir + '/usability.dtd'
def personas(self):
return self.thePersonas
def externalDocuments(self):
return self.theExternalDocuments
def documentReferences(self):
return self.theDocumentReferences
def conceptReferences(self):
return self.theConceptReferences
def personaCharacteristics(self):
return self.thePersonaCharacteristics
def taskCharacteristics(self):
return self.theTaskCharacteristics
def tasks(self):
return self.theTasks
def usecases(self):
return self.theUseCases
def resetPersonaAttributes(self):
self.inActivities = 0
self.inAttitudes = 0
self.inAptitudes = 0
self.inMotivations = 0
self.inSkills = 0
self.inIntrinsic = 0
self.inContextual = 0
self.theName = ''
self.theTags = []
self.theType = ''
self.theImage = ''
self.isAssumptionPersona = False
self.theActivities = ''
self.theAptitudes = ''
self.theMotivations = ''
self.theSkills = ''
self.theIntrinsic = ''
self.theContextual = ''
self.theEnvironmentProperties = []
self.resetPersonaEnvironmentAttributes()
def resetPersonaEnvironmentAttributes(self):
self.theEnvironmentName = ''
self.theRoles = []
self.isDirect = True
self.inNarrative = 0
self.theNarrative = ''
def resetExternalDocumentAttributes(self):
self.theName = ''
self.theVersion = ''
self.theDate = ''
self.theAuthors = ''
self.inDescription = 0
self.theDescription = ''
def resetDocumentReferenceAttributes(self):
self.inExcerpt = 0
self.theName = ''
self.theContributor = ''
self.theDocument = ''
self.theExcerpt = ''
def resetConceptReferenceAttributes(self):
self.inDescription = 0
self.theName = ''
self.theConcept = ''
self.theObject = ''
self.theDescription = ''
def resetPersonaCharacteristicAttributes(self):
self.thePersona = ''
self.theBvName = ''
self.theModalQualifier = ''
self.inDefinition = 0
self.theDefinition = ''
self.theGrounds = []
self.theWarrants = []
self.theRebuttals = []
def resetTaskCharacteristicAttributes(self):
self.theTask = ''
self.theModalQualifier = ''
self.inDefinition = 0
self.theDefinition = ''
self.theGrounds = []
self.theWarrants = []
self.theRebuttals = []
def resetTaskAttributes(self):
self.theName = ''
self.theTags = []
self.theCode = ''
self.theAuthor = ''
self.isAssumptionTask = False
self.inObjective = 0
self.theObjective = ''
self.theEnvironmentProperties = []
self.resetTaskEnvironmentAttributes()
def resetTaskEnvironmentAttributes(self):
self.theEnvironmentName = ''
self.inDependencies = 0
self.inNarrative = 0
self.inConsequences = 0
self.inBenefits = 0
self.theDependencies = ''
self.theNarrative = ''
self.theConsequences = ''
self.theBenefits = ''
self.theTaskPersonas = []
self.theConcerns = []
self.theConcernAssociations = []
def resetUseCaseAttributes(self):
self.theName = ''
self.theTags = []
self.theAuthor = ''
self.theCode = ''
self.inDescription = 0
self.theDescription = ''
self.theActors = []
self.theEnvironmentProperties = []
self.resetUseCaseEnvironmentAttributes()
def resetUseCaseEnvironmentAttributes(self):
self.theEnvironmentName = ''
self.inPreconditions = 0
self.thePreconditions = ''
self.inPostconditions = 0
self.thePostconditions = ''
self.theSteps = Steps()
self.theCurrentStep = None
self.theCurrentStepNo = 0
self.theExcName = ''
self.theExcType = ''
self.theExcValue = ''
self.theExcCat = ''
self.inDefinition = 0
self.theDefinition = ''
def startElement(self, name, attrs):
self.currentElementName = name
if name == 'persona':
self.theName = attrs['name']
self.theType = attrs['type']
self.theImage = attrs['image']
if (attrs['assumption_persona'] == 'TRUE'):
self.isAssumptionPersona = True
elif name == 'persona_environment':
self.theEnvironmentName = attrs['name']
if (attrs['is_direct'] == 'FALSE'):
self.isDirect = False
elif name == 'persona_role':
self.theRoles.append(attrs['name'])
elif name == 'external_document':
self.theName = attrs['name']
self.theVersion = attrs['version']
self.theDate = attrs['date']
self.theAuthors = attrs['authors']
elif name == 'document_reference':
self.theName = attrs['name']
self.theContributor = attrs['contributor']
self.theDocument = attrs['document']
elif name == 'concept_reference':
self.theName = attrs['name']
self.theConcept = attrs['concept']
self.theObject = attrs['object']
elif name == 'persona_characteristic':
self.thePersona = attrs['persona']
self.theBvName = u2s(attrs['behavioural_variable'])
self.theModalQualifier = attrs['modal_qualifier']
elif name == 'task_characteristic':
self.theTask = attrs['task']
self.theModalQualifier = attrs['modal_qualifier']
elif name == 'grounds':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theGrounds.append((refName, '', refType))
elif name == 'warrant':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theWarrants.append((refName, '', refType))
elif name == 'rebuttal':
refName = attrs['reference']
refType = attrs['type']
refArtifact = ''
self.theRebuttals.append((refName, '', refType))
elif name == 'task':
self.theName = attrs['name']
try:
self.theCode = attrs['code']
except KeyError:
self.theCode = ''
self.theAuthor = attrs['author']
if (attrs['assumption_task'] == 'TRUE'):
self.isAssumptionTask = True
elif name == 'task_environment':
self.theEnvironmentName = attrs['name']
elif name == 'task_persona':
self.theTaskPersonas.append(
(attrs['persona'], durationValue(attrs['duration']),
frequencyValue(attrs['frequency']), attrs['demands'],
attrs['goal_conflict']))
elif name == 'task_concern':
self.theConcerns.append(attrs['asset'])
elif name == 'task_concern_association':
self.theConcernAssociations.append(
(attrs['source_name'], a2s(attrs['source_nry']),
attrs['link_name'], attrs['target_name'],
a2s(attrs['target_nry'])))
elif name == 'usecase':
self.theName = attrs['name']
self.theAuthor = attrs['author']
self.theCode = attrs['code']
elif name == 'actor':
self.theActors.append(attrs['name'])
elif name == 'usecase_environment':
self.theEnvironmentName = attrs['name']
elif name == 'step':
self.theCurrentStepNo = attrs['number']
self.theCurrentStep = Step(attrs['description'])
elif name == 'exception':
self.theExcName = attrs['name']
self.theExcType = attrs['type']
self.theExcValue = attrs['value']
self.theExcCat = u2s(attrs['category'])
elif name == 'activities':
self.inActivities = 1
self.theActivities = ''
elif name == 'attitudes':
self.inAttitudes = 1
self.theAttitudes = ''
elif name == 'aptitudes':
self.inAptitudes = 1
self.theAptitudes = ''
elif name == 'motivations':
self.inMotivations = 1
self.theMotivations = ''
elif name == 'skills':
self.inSkills = 1
self.theSkills = ''
elif name == 'intrinsic':
self.inIntrinsic = 1
self.theIntrinsic = ''
elif name == 'contextual':
self.inContextual = 1
self.theContextual = ''
elif name == 'narrative':
self.inNarrative = 1
self.theNarrative = ''
elif name == 'consequences':
self.inConsequences = 1
self.theConsequences = ''
elif name == 'benefits':
self.inBenefits = 1
self.theBenefits = ''
elif name == 'excerpt':
self.inExcerpt = 1
self.theExcerpt = ''
elif name == 'description':
self.inDescription = 1
self.theDescription = ''
elif name == 'definition':
self.inDefinition = 1
self.theDefinition = ''
elif name == 'dependencies':
self.inDependencies = 1
self.theDependencies = ''
elif name == 'objective':
self.inObjective = 1
self.theObjective = ''
elif name == 'preconditions':
self.inPreconditions = 1
self.thePreconditions = ''
elif name == 'postconditions':
self.inPostconditions = 1
self.thePostconditions = ''
elif name == 'tag':
self.theTags.append(attrs['name'])
def characters(self, data):
if self.inActivities:
self.theActivities += data
elif self.inAttitudes:
self.theAttitudes += data
elif self.inAptitudes:
self.theAptitudes += data
elif self.inMotivations:
self.theMotivations += data
elif self.inSkills:
self.theSkills += data
elif self.inIntrinsic:
self.theIntrinsic += data
elif self.inContextual:
self.theContextual += data
elif self.inConsequences:
self.theConsequences += data
elif self.inBenefits:
self.theBenefits += data
elif self.inExcerpt:
self.theExcerpt += data
elif self.inDescription:
self.theDescription += data
elif self.inDefinition:
self.theDefinition += data
elif self.inDependencies:
self.theDependencies += data
elif self.inObjective:
self.theObjective += data
elif self.inPreconditions:
self.thePreconditions += data
elif self.inPostconditions:
self.thePostconditions += data
elif self.inNarrative:
self.theNarrative += data
def endElement(self, name):
if name == 'persona':
p = PersonaParameters(self.theName, self.theActivities,
self.theAttitudes, self.theAptitudes,
self.theMotivations, self.theSkills,
self.theIntrinsic, self.theContextual,
self.theImage, self.isAssumptionPersona,
self.theType, self.theTags,
self.theEnvironmentProperties, {})
self.thePersonas.append(p)
self.resetPersonaAttributes()
elif name == 'persona_environment':
p = PersonaEnvironmentProperties(self.theEnvironmentName,
self.isDirect, self.theNarrative,
self.theRoles, {'narrative': {}})
self.theEnvironmentProperties.append(p)
self.resetPersonaEnvironmentAttributes()
elif name == 'external_document':
p = ExternalDocumentParameters(self.theName, self.theVersion,
self.theDate, self.theAuthors,
self.theDescription)
self.theExternalDocuments.append(p)
self.resetExternalDocumentAttributes()
elif name == 'document_reference':
p = DocumentReferenceParameters(self.theName, self.theDocument,
self.theContributor,
self.theExcerpt)
self.theDocumentReferences.append(p)
self.resetDocumentReferenceAttributes()
elif name == 'concept_reference':
p = ConceptReferenceParameters(self.theName, self.theConcept,
self.theObject, self.theDescription)
self.theConceptReferences.append(p)
self.resetConceptReferenceAttributes()
elif name == 'persona_characteristic':
p = PersonaCharacteristicParameters(
self.thePersona, self.theModalQualifier, self.theBvName,
self.theDefinition, self.theGrounds, self.theWarrants, [],
self.theRebuttals)
self.thePersonaCharacteristics.append(p)
self.resetPersonaCharacteristicAttributes()
elif name == 'task_characteristic':
p = TaskCharacteristicParameters(self.theTask,
self.theModalQualifier,
self.theDefinition,
self.theGrounds, self.theWarrants,
[], self.theRebuttals)
self.theTaskCharacteristics.append(p)
self.resetTaskCharacteristicAttributes()
elif name == 'task':
p = TaskParameters(self.theName, self.theCode, self.theObjective,
self.isAssumptionTask, self.theAuthor,
self.theTags, self.theEnvironmentProperties)
self.theTasks.append(p)
self.resetTaskAttributes()
elif name == 'task_environment':
p = TaskEnvironmentProperties(
self.theEnvironmentName, self.theDependencies,
self.theTaskPersonas, self.theConcerns,
self.theConcernAssociations, self.theNarrative,
self.theConsequences, self.theBenefits, {
'narrative': {},
'consequences': {},
'benefits': {}
})
self.theEnvironmentProperties.append(p)
self.resetTaskEnvironmentAttributes()
elif name == 'exception':
self.theCurrentStep.addException(
(self.theExcName, self.theExcType, self.theExcValue,
self.theExcCat, self.theDefinition))
elif name == 'step':
self.theCurrentStep.setTags(self.theTags)
self.theSteps.append(self.theCurrentStep)
self.theCurrentStep = None
elif name == 'usecase_environment':
p = UseCaseEnvironmentProperties(self.theEnvironmentName,
self.thePreconditions,
self.theSteps,
self.thePostconditions)
self.theEnvironmentProperties.append(p)
self.resetUseCaseEnvironmentAttributes()
elif name == 'usecase':
p = UseCaseParameters(self.theName, self.theAuthor, self.theCode,
self.theActors, self.theDescription,
self.theTags, self.theEnvironmentProperties)
self.theUseCases.append(p)
self.resetUseCaseAttributes()
elif name == 'activities':
self.inActivities = 0
elif name == 'attitudes':
self.inAttitudes = 0
elif name == 'aptitudes':
self.inAptitudes = 0
elif name == 'motivations':
self.inMotivations = 0
elif name == 'skills':
self.inSkills = 0
elif name == 'intrinsic':
self.inIntrinsic = 0
elif name == 'contextual':
self.inContextual = 0
elif name == 'narrative':
self.inNarrative = 0
elif name == 'excerpt':
self.inExcerpt = 0
elif name == 'description':
self.inDescription = 0
elif name == 'definition':
self.inDefinition = 0
elif name == 'dependencies':
self.inDependencies = 0
elif name == 'objective':
self.inObjective = 0
elif name == 'preconditions':
self.inPreconditions = 0
elif name == 'postconditions':
self.inPostconditions = 0
elif name == 'benefits':
self.inBenefits = 0
elif name == 'consequences':
self.inConsequences = 0
