def ask_user_task_amount(df, num_sur_q):
"""Asks for user input to determine how many surveys were given to the
participant in the study.
Args:
df: A cleaned DataFrame of the Qualtrics export.
num_sur_q(int): Total number of questions asked in surveys.
Returns:
task_amount(int): The number of questions in each survey.
"""
poten_task_amts = [x for x in range(2, 30) if num_sur_q % x == 0]
if len(poten_task_amts) > 1:
print(f"Judging by the numbers, it looks like there are multiple ways"
" in which these questions could be broken up. Please answer the"
" question(s) below to continue to attempt to parse the data.\n")
for poten_task_amt in poten_task_amts:
ans = InputManager.get_yes_or_no(f"Where there {poten_task_amt} "
"total tasks in your study?")
if ans:
task_amount = poten_task_amt
return task_amount
break
elif len(poten_task_amts) == 1:
ans = InputManager.get_yes_or_no(
f"There were {poten_task_amts} in your"
" study? (Y/n): ")
if not ans:
clean_getaway()
task_amount = poten_task_amts[0]
return task_amount
else:
clean_getaway()
def main():
pygame.init()
window = Window(1092, 780)
input_m = InputManager()
physics = PhysicsEngine()
logic = LogicManager()
clock = pygame.time.Clock()
entities = spawn_entities_level_one()
running = True
level = 1
while(running):
try:
running = input_m.update()
clock.tick()
dt = clock.get_time()
logic.update(entities, input_m, dt)
physics.update(entities, dt)
window.render(entities, dt)
except NewLevelException:
window.change_level(clock,
pygame.Rect(650, 480, 100, 100),
3000)
entities = spawn_entities_level_two()
level = 2
except ResetLevelException:
if level == 2:
entities = spawn_entities_level_two()
window.enter_level2()
else:
entities = spawn_entities_level_one()
def main():
# create the managers
eMngr = EventManager()
gMngr = GraphicManager(eMngr)
iMngr = InputManager(eMngr, gMngr)
uMngr = UpdateManager(eMngr)
sMngr = SoundManager(eMngr)
nMngr = NetworkManager(eMngr)
print "starting game"
# create file with input
playFile = open(sys.argv[1], 'r')
# start the managers
eMngr.start()
gMngr.start()
iMngr.start()
uMngr.start()
sMngr.start()
nMngr.start()
# create game and start it
# FIXME playfile should be passed to the updateManager
game = Game(iMngr, uMngr, gMngr, sMngr, nMngr, playFile)
game.run()
# close the managers
eMngr.stop()
uMngr.stop()
iMngr.stop()
gMngr.stop()
sMngr.stop()
nMngr.stop()
def __init__(self) -> None:
self.groupByTag = True
self.taskManager = TaskManager()
self.calendarView = CalendarView(self.taskManager)
# self.overview = Overview(self.taskManager.tasks)
self.taskView = TaskView(self.taskManager, groupByTag=self.groupByTag)
# self.layout = self.MakeLayout()
self.inputManager = InputManager(self.taskManager)
self.loop = True
def get_survey_information(apiToken, dataCenter="ca1"):
"""Prints a list of the current survey names and corresponding Ids and asks
the user which survey they want to recieve an export from.
Args:
apiToken(str): A string of characters that allows allows authentication
when querying the Qualtrics API.
dataCenter(str): Data center arguement for Qualtrics API.
Returns:
surveyID(str): A unique ID corresponding the to survey the user wants to
retreieve survey responses for.
Bool(False): If a surveyId isn't selected or found."""
baseUrl = f"https://{dataCenter}.qualtrics.com/API/v3/surveys"
headers = {
"x-api-token": apiToken,
}
response = requests.get(baseUrl, headers=headers)
try:
survey_info = json.loads(response.text)['result']['elements']
except KeyError:
print(json.loads(response.text))
print("You are presenting an invalid API token to qualtrics. "
"Please make sure that your API token exactly matches"
"the token listed on the Qualtrics account and try again.")
sys.exit()
print("\nBelow are the surveys listed under your qualtrics account:\n")
print("-" * 80)
if len(survey_info) == 0:
print("There are no surveys associated with your Qualtrics account.")
print("Quitting this program.. .. ..")
sys.exit()
for i, survey in enumerate(survey_info):
print(f"{i + 1}. - Survey Name: {survey['name']}")
print(f"Survey ID: {survey['id']}")
print("-" * 80)
prompt = (
"Which survey would you like to export? \n(indicate the survey by typing the number listed next to the survey): "
)
survey_response = InputManager.get_numerical_input(prompt,
(len(survey_info)))
surveyId = survey_info[survey_response - 1]['id']
if surveyId:
prompt = "Would you like to save this as your default survey? \n(Answering yes will save the id to '/.ids/surveyid.txt')"
ans = InputManager.get_yes_or_no(prompt)
if ans:
if not os.path.exists(f"{os.getcwd()}/.ids/"):
os.mkdir(f"{os.getcwd()}/.ids/")
with open(f"{os.getcwd()}/.ids/surveyid.txt", "w") as out_file:
out_file.write(surveyId)
return surveyId
return False
def find_first_q(df):
"""Asks the user if the first question left over in the cleaned df is the
first question of their survey. It also informs that user that the first
question should be in the question asking for the participant's ID.
Args:
df: a (cleaned) DataFrame of the qualtrics data export.
Returns: None"""
try:
first_q = df.iloc[0][0]
except:
return None
ans = InputManager.get_yes_or_no(
"\033[1m CHECKING FIRST QUESTION:"
f"\n\n'{first_q}'\033[0m\n\n"
"is the above the first survey question "
"in your survey?: (Y/n) \n\n"
"\033[1mNOTE:\033[0m This question should "
"be asking for the experimenter to enter "
"the participant's ID number.")
if ans:
return first_q
else:
clean_getaway()
def __init__(self, fnirs_file="./sampledata/samplefnirs/test_1.csv"):
self.fnirs_file = fnirs_file
self.df = pd.read_csv(fnirs_file, header=34)
self.mark_col = self.df["Mark"].tolist()
self.marks = [mark for mark in self.mark_col if mark > 0]
self.mark_indexes = [indx for indx, mark in enumerate(self.mark_col)
if mark > 0]
self.valid_marks = self.validate_marks(self.marks)
self.valid_spaceing = self.validate_spacing(self.mark_indexes)
if self.valid_marks:
print("Marking appears to be valid. Even number of marks found. \n")
if self.valid_spaceing:
print("Spacing between marks appears to be valid.\n")
print(f"Mark values:\n{self.mark_counts}")
print(f"Number of space warnings: {len(self.space_warnings)}. \n")
self.onsets = self.get_onsets(self.mark_indexes)
self.task_number = len(self.onsets)
self.durations = self.get_durations(self.onsets)
else:
print("\033[1mWARNING:\033[0m\n"
"Something appears to have gone wrong in the marking "
"of this file. fNIRS marks need to be opened and closed. "
"You can continue to attempt to parse the file, but the "
"outcomes may not be correct. Make sure to check outputs "
"for validity if you decide to continue. ")
ans = InputManager.get_yes_or_no("Try anyway? (Y/n): ")
if not ans:
pass
self.get_onsets()
def find_slice_prompt(df):
"""Finds the string value that the script will use to slice the survey data
up by - the first question asked in the beginning of each survey.
Args:
df: A cleaned DataFrame from the Qualtrics export.
Returns:
slice_prompt(str): The string value of the first survey question in each
survey."""
questions_list = df.iloc[0].tolist()
num_of_q_per_task, num_of_tasks, num_prelim_qs = get_slice_prompt_index(df)
print(f"There were {int(num_of_q_per_task)} questions per task.")
print(f"There were {num_of_tasks} tasks total")
print(f"The first {num_prelim_qs} were preliminary questions.")
slice_prompt = questions_list[num_prelim_qs]
ans = InputManager.get_yes_or_no(
"\033[1m CHECKING FIRST SURVEY QUESTION:"
f"\n\n'{slice_prompt}'\033[0m\n\n"
"is the above the first survey question "
"in your survey?: (Y/n) \n\n"
"\033[1mNOTE:\033[0m This question should "
"be asking for the experimenter to enter "
"the task the participant just completed.")
if not ans:
clean_getaway()
return slice_prompt
def get_api_fpath():
"""Allows user to manually import filepath that and contains their API token.
Args:
None
Returns:
api_fpath(str): location of the file containing user's API key.
Bool (False): If user does not want to manually enter the filepath."""
ans = InputManager.get_yes_or_no(
"Would you like to manually enter the filepath where your API token is located?: (Y/n): "
)
if ans:
fpath = InputManager.get_valid_fpath("Please enter a valid filepath: ")
return fpath
return False
def __init__(self): self.game=Gamelolz(self) self.menu=menulists global inputmanager #because everyone should be able to access it. self.inputmanager=InputManager(self.game) #pygame.register_quit(self.inputmanager.sysexit) self.menu.init_menu() self.game.start() while self.menu.exit_menu(self.game.points): self.game.start()
def main():
# create the managers
eMngr = EventManager()
gMngr = GraphicManager(eMngr)
iMngr = InputManager(eMngr, gMngr)
uMngr = UpdateManager(eMngr)
sMngr = SoundManager(eMngr)
nMngr = NetworkManager(eMngr)
print "starting game"
# create file with input
playFile = open(sys.argv[1], 'r')
# start the managers
eMngr.start()
gMngr.start()
iMngr.start()
uMngr.start()
sMngr.start()
nMngr.start()
# create game and start it
# FIXME playfile should be passed to the updateManager
game = Game(iMngr, uMngr, gMngr, sMngr, nMngr, playFile)
game.run()
# close the managers
eMngr.stop()
uMngr.stop()
iMngr.stop()
gMngr.stop()
sMngr.stop()
nMngr.stop()
def main():
maze = maze_gen.Maze(5, 5)
input_manager = InputManager()
player_agent =\
QLearningAgent(
initial_q=0.1,
learning_rate=0.9,
discount_factor=0.9)
# target_agent =\
# WaitAndRunAgent(
# 100000,
# QLearningAgent(
# initial_q=0,
# learning_rate=0.9,
# discount_factor=0.9))
target_agent =\
QLearningAgent(
initial_q=0,
learning_rate=0.9,
discount_factor=0.9)
env = \
MazeGameGuiEnvironment(
maze,
player_agent,
target_agent,
input_manager)
count = 0
while count < 10000:
env.reset()
done = env.step()
while not done:
done = env.step()
print(len(env.get_record()["a"]))
count += 1
np.save("q_state_action",
np.array((list(k[0] + (k[1], ) for k in player_agent.q))))
np.save("q_target_value",
np.array((list((v, ) for k, v in player_agent.q.items()))))
def get_prelim_qs(df):
"""Asks the user to input the amount of questions in the survey that do not
correspond to survey questions given to the participant (preliminary
questions).
Args:
df: A cleaned DataFrame of the Qualtrics export.
Returns:
num_prelim_qs(int): The number of questions before the experiment began.
"""
num_prelim_qs = InputManager.get_numerical_input(
"How many preliminary "
"questions were asked "
"before the experiment "
"began?: ", 9)
return num_prelim_qs
def get_col_names(self):
"""Asks the user to rename the columns if they were not properly named
before.
"""
new_col_names = []
for col_name in self.df.columns:
ans = InputManager.get_variable_name(f"Input a measure name "
f"for column: {col_name}. "
"Type 'd' to drop col, "
" or 'k' to keep default: ")
if ans == 'k':
new_col_names.append(col_name)
elif ans == 'd':
self.df.drop(col_name)
else:
new_col_names.append(ans)
self.df.columns = new_col_names
def __init__(self):
"""Base class initializer.
Initialize base class and manager classes. Manager classes and their methods form the Driftwood Scripting API.
Attributes:
config: ConfigManager instance.
log: LogManager instance.
database: DatabaseManager instance.
filetype: Shortcut to filetype module.
tick: TickManager instance.
path: PathManager instance.
cache: CacheManager instance.
resource: ResourceManager instance.
input: InputManager instance.
window: WindowManager instance.
entity: EntityManager instance.
area: AreaManager instance.
script: ScriptManager instance.
keycode: Contains the SDL keycodes.
running: Whether the mainloop should continue running. Set False to shut down the engine.
"""
self.config = ConfigManager(self)
self.log = LogManager(self)
self.database = DatabaseManager(self)
self.tick = TickManager(self)
self.path = PathManager(self)
self.cache = CacheManager(self)
self.resource = ResourceManager(self)
self.input = InputManager(self)
self.window = WindowManager(self)
self.entity = EntityManager(self)
self.area = AreaManager(self)
self.script = ScriptManager(self)
# SDL Keycodes.
self.keycode = keycode
self.running = False
def main():
global inputmanager, screen, board
#init graphics
init()
size = (150, 150)
screen = set_mode(size)
#init game data
nr_of_rectangles = 9
board = TicTacToeBoard(nr_of_rectangles)
#board.paint(screen)
#init input
inputmanager = InputManager([
("Mouse", 1, "Press",
(lambda: board.make_turn(Point(get_pos()[0],
get_pos()[1])))),
("Key", K_UP, "Press", (lambda: print("Hello Keyboard!"))),
])
loop()
def get_q_measures(num_questions):
"""Prompts the user in input the operational conditionals value titles for
all of the questions in their survey. These value titles will serve as row
headings in the conditions files.
Args:
num_questions(int): Number of questions administered in a survey given
the the participant after each task.
Returns:
q_measures(list): A list of the row headings for the completed
conditions file."""
keyword_measures = {
"tlx": [
"", "onset", "duration", "stim", "tlx", "tlx_mental",
"tlx_physical", "tlx_temporal", "tlx_performance", "tlx_effort",
"tlx_frustration"
],
"mrq": ["", "onset", "duration", "stim", "mrq"],
}
q_measures = []
for x in range(0, num_questions + 1):
if x == 0:
q_measures.append("")
elif x == 1:
q_measures.append("stim")
else:
prompt = (f"Please enter the measurement name for"
f" question {x + 1} in the survey.")
measure = InputManager.get_variable_name(prompt)
q_measures.append(measure)
if measure in keyword_measures:
return keyword_measures[measure]
elif measure == "default":
return [f"measure {x}" for x in range(0, num_questions + 1)]
return q_measures
def __init__(self, qual_export=None, clean_it=True, marking=True,
mark_str=" ", ignore_warnings=False, template=None):
self.template = template
if self.template:
self.load_template_params(template)
else:
self.mark_str = mark_str
self.ignore_warnings = ignore_warnings
self.data_files_not_found = []
if not qual_export:
qual_export = InputManager.get_valid_fpath("Please enter a filepath "
"for the Qualtrics export "
"you wish to parse: ")
self.load_in_file(qual_export)
if clean_it:
self.clean_qualtrics_export()
self.set_headers()
if marking:
self.checks_out = self.find_marks(mark_str)
self.select_parsing_process()
self.make_headings_col()
def leave_any_out(df):
"""Asks the user if there is any section of the survey they would like
to leave out of the parsing process.
Args:
df: A cleaned Qualtrics survey export.
Returns:
df: A cleaned Qualtrics export with the proper columns removed."""
ans = InputManager.get_yes_or_no(
"Are there any columns you not like to"
" include in the conditions files? (Y/n):")
if ans:
first_prompt = input("Please enter the first prompt for the section "
"you wish to remove: ")
how_many_after = int(
input("How many columns do you wish to remove "
" after the first prompt?: "))
headings_list = df.iloc[0].tolist()
first_indx = headings_list.index(first_prompt)
cols_to_remove = headings_list[first_indx:first_indx + how_many_after]
df.drop(cols_to_remove, axis=1, inplace=True)
return df
class LiveLayoutView():
'''
docstring
'''
### TODO, send taskmanager itself for a single source of truth.
def __init__(self) -> None:
self.groupByTag = True
self.taskManager = TaskManager()
self.calendarView = CalendarView(self.taskManager)
# self.overview = Overview(self.taskManager.tasks)
self.taskView = TaskView(self.taskManager, groupByTag=self.groupByTag)
# self.layout = self.MakeLayout()
self.inputManager = InputManager(self.taskManager)
self.loop = True
# self.input = ''
def RichLayout(self) -> Layout:
layout = Layout()
layout.split(
# Layout(name="upper"),
Layout(" ", name="BufferTop"),
Layout(Panel(self.calendarView.RichGrid(),
title="Calendar",
style='grey50'),
name="Calendar"),
Layout(Panel(self.taskView.RichGrid(),
title="Tasks",
style='grey50'),
name="Tasks"),
# Layout(Panel(str(datetime.now()), title="Console"), name="Console")
Layout(self.inputManager.RichGrid(), name='Console')
# Layout(" ", name="BufferBot")
# Layout(datetime.datetime.now().strftime('%H:%M:%S') + ' ' + self.input, name='Console')
)
# layout["upper"].split(
# Layout(Panel(self.calendarView.RichGrid(), title="Calendar"), name="Calendar"),
# # Layout(Panel(self.overview.RichGrid(), title="Overview"), name="Overview"),
# direction="horizontal"
# )
# layout['Calendar'].ratio = 2.5
# layout['Overview'].ratio =
layout["BufferTop"].size = 1
layout["Tasks"].ratio = 1.5
# layout["BufferBot"].size = 1
layout['Console'].size = 1
return layout
def LiveRender(self):
'''
docstring
'''
# term = Terminal()
# print(self.RichLayout())
# while True:
response = ''
initial = ''
timedOut = False
console = Console()
with Live(console=console,
auto_refresh=False,
screen=True,
vertical_overflow='ellipsis',
redirect_stdout=False,
redirect_stderr=False) as live:
# term.inkey(timeout=5)
live.update(self.RichLayout(), refresh=True)
while response != 'exit':
response, timedOut = inputAdv('', initial, 3600)
if timedOut:
initial = response
else:
initial = ''
self.inputManager._ExecuteInput(response.strip())
live.update(self.RichLayout(), refresh=True)
class Driftwood:
"""The top-level base class
This class contains the top level manager class instances and the mainloop. The instance of this class is
passed to scripts as an API reference.
"""
def __init__(self):
"""Base class initializer.
Initialize base class and manager classes. Manager classes and their methods form the Driftwood Scripting API.
Attributes:
config: ConfigManager instance.
log: LogManager instance.
database: DatabaseManager instance.
filetype: Shortcut to filetype module.
tick: TickManager instance.
path: PathManager instance.
cache: CacheManager instance.
resource: ResourceManager instance.
input: InputManager instance.
window: WindowManager instance.
entity: EntityManager instance.
area: AreaManager instance.
script: ScriptManager instance.
keycode: Contains the SDL keycodes.
running: Whether the mainloop should continue running. Set False to shut down the engine.
"""
self.config = ConfigManager(self)
self.log = LogManager(self)
self.database = DatabaseManager(self)
self.tick = TickManager(self)
self.path = PathManager(self)
self.cache = CacheManager(self)
self.resource = ResourceManager(self)
self.input = InputManager(self)
self.window = WindowManager(self)
self.entity = EntityManager(self)
self.area = AreaManager(self)
self.script = ScriptManager(self)
# SDL Keycodes.
self.keycode = keycode
self.running = False
def run(self):
"""Perform startup procedures and enter the mainloop.
"""
# Only run if not already running.
if not self.running:
self.running = True
# Execute the init function of the init script if present.
if not self.path["init.py"]:
self.log.msg("WARNING", "Driftwood", "init.py missing, nothing will happen")
else:
self.script.call("init.py", "init")
# Escape key pauses the engine.
self.input.register(self.keycode.SDLK_ESCAPE, self.__handle_pause)
# This is the mainloop.
while self.running:
# Process SDL events.
sdlevents = sdl2ext.get_events()
for event in sdlevents:
if event.type == SDL_QUIT:
# Stop running.
self.running = False
elif event.type == SDL_KEYDOWN:
# Pass a keydown to the Input Manager.
self.input._key_down(event.key.keysym.sym)
elif event.type == SDL_KEYUP:
# Pass a keyup to the Input Manager.
self.input._key_up(event.key.keysym.sym)
elif event.type == SDL_WINDOWEVENT and event.window.event == SDL_WINDOWEVENT_EXPOSED:
self.window.refresh()
# Process tick callbacks.
self.tick.tick()
print("Shutting down...")
return 0
def __handle_pause(self, keyevent):
if keyevent == InputManager.ONDOWN:
# Shift+Escape shuts down the engine.
if self.input.pressed(self.keycode.SDLK_LSHIFT) or self.input.pressed(self.keycode.SDLK_RSHIFT):
self.running = False
else:
self.tick.toggle_pause()
