def buildRoster():
labWarriors = ["Mike", "Kenway", "Ryan", "Christian", "Marc", "Tommy"]
labRoster = roster.Roster()
for warriorName in labWarriors:
warrior = pongwarrior.PongWarrior(warriorName)
labRoster.addWarrior(warrior)
return labRoster
def getRoster(self): """ Return the Roster instance, previously plugging it in and requesting roster from server if needed. """ if not hasattr(self, "Roster"): roster.Roster().plugIn(self) return self.Roster.getRoster()
def FindUnsedErrata(errata_file='roster_errata.csv', roster_file=None):
"""menu.FindUnsedErrata
INPUTS:
- none
OUTPUTS:
Prints the roster errata entries that are no longer found in the roster, and can be
removed.
ASSUMPTIONS:
- none
"""
##
## Read the adults from the most recent roster file
adults_list = roster_tools.ReadRosterAdultsFromMostRecent(
file_name=roster_file)
##
## Next, instantiate a Roster class, which includes the default errata, and retrieve
## that dictionary
temp = roster.Roster(show_errors='y', file_name=errata_file)
all_errata = temp.GetErrata()
##
## for each error listed in the errata, look for it in the adults list
unused_errata = []
for entry in all_errata.keys():
if entry not in adults_list:
unused_errata.append(entry)
return unused_errata, all_errata
def _get(self, conn):
bare = conn.authJID.bare
aroster = self._rosters.get(bare)
if aroster is None:
## Automatically create an empty roster.
aroster = self._rosters[bare] = roster.Roster(bare, conn)
return aroster
def initiateNewQueue(self):
contents = ''
importlib.reload(students)
with open('students.py', 'r') as file:
contents = file.read()
contents = contents.strip("students_dict = ")
studentDict = ast.literal_eval(contents)
self.studentQueue = queue.Queue(roster.Roster(studentDict))
return
def process(self):
try:
self._log.info("Processing roster for " + datetime.datetime.now().strftime("%d/%m/%Y") + "...")
self._log.info("===========================================================")
self._log.info("Current path is: " + self._httppath)
self._log.info("Downloading...")
if self._download():
self._log.info("Comparing " + self._name + " roster against existing versions...")
if self._locateLastFile(self._xlsxpath, ROSTERNAME, self._excelxtn) and self._compareFiles(self._xlsxfull,self._locateLastFile(self._xlsxpath, ROSTERNAME, self._excelxtn)):
self._log.info("No changes to roster since last download. Removing downloaded file: " + self._name + self._excelxtn)
os.remove(self._xlsxfull)
self._log.info("File deleted. No further actions required.")
else:
self._log.info("Downloaded file is newer than the last available version.")
self._log.info("Converting to *.csv")
self._convert()
self._log.info("Emailing latest versions..")
currentRoster = roster.Roster(self._csvfull)
prevRoster = roster.Roster(self._locateLastFile(self._csvpath, ROSTERNAME, self._csvxtn))
today = datetime.datetime.now().strftime("%d/%m/%Y")
fortnite = (datetime.datetime.now() + datetime.timedelta(days=14)).strftime("%d/%m/%Y")
self._log.info("Resources allocated, looping...")
for key in self._recips:
if currentRoster.showMemberPeriod(key,today,fortnite) == prevRoster.showMemberPeriod(key,today,fortnite):
self._log.info("{0} is the same in both rosters between {1} and {2}. Skipping...".format(key, today, fortnite))
else:
self._log.info("{0} is different between {1} and {2}. Emailing to {3}...".format(key, today, fortnite,str(self._recips[key])))
self._email(key,self._recips[key],currentRoster.showMemberPeriod(key,today,fortnite),prevRoster.showMemberPeriod(key,today,fortnite))
else:
self._log.info("File '" + self._name + "' already exists!")
self._log.info("Aborting file conversion...")
self._log.info("Aborting emailing files...")
self._log.info("Please complete these manually or remove the following file and re-run the process:")
self._log.info(self._xlsxfull)
self._log.info("===========================================================")
self._log.info("Processing complete!")
except Exception as e:
self._log.error("##################")
self._log.error("PROCESSING FAILED!")
self._log.error("##################")
self._log.error(str(e))
def ReadRoster(hub_map):
""" roster_tools.ReadRoster
PURPOSE:
Prompts the user for roster file name and proceeds to read the file.
INPUT:
- hub_map -- mapping of teacher names to hub numbers
OUTPUTS:
- roster -- list of families extracted from the roster
ASSUMPTIONS:
- All the candidate rosters reside in a folder called "Roster" under the
run directory.
- All candidate rosters are Microsoft Excel files.
"""
return ReadRosterFromFile(GetRosterFileName(), hub_map, roster.Roster())
def __init__(self, parent=None):
super(GUI, self).__init__(parent)
self.resize(600, 500)
self.setWindowTitle('KIT-Card Reader')
self.setFont(QFont('Helvetica', 24))
# 名簿をロード
self.roster = roster.Roster()
# 空の縦レイアウトを作る
layout = QVBoxLayout()
self.setLayout(layout)
# コンボボックス
cbox_labels = [
f'{course_code} {course_name}'
for course_code, course_name in self.roster.courses.items()
]
self.cb1 = QComboBox(self)
self.cb1.addItems(cbox_labels)
layout.addWidget(self.cb1)
# ラベル
self.state = 'IDLE'
self.l1 = QLabel(self.state)
self.l1.setAlignment(Qt.AlignCenter)
self.l1.setStyleSheet('color: black; font-size: 64pt')
layout.addWidget(self.l1)
# ボタン
self.b1 = QPushButton('受付開始', self)
self.b1.setStyleSheet('background-color: darkblue;'
'color: white; font-size: 32pt')
self.b1.clicked.connect(self.b1_callback)
layout.addWidget(self.b1)
# ブザー
self.buzzer = Buzzer()
# タイマー(100ミリ秒ごとのインタバルタイマ)
self.timer = QTimer()
self.timer.setSingleShot(False)
self.timer.setInterval(100)
self.timer.timeout.connect(self.on_timer)
self.wait = DELAY
self.blocked = False
self.last_student_id = None
self.timer.start()
def initiateSavedQueue(self):
contents = ''
with open('students.py', 'r') as file:
contents = file.read()
contents = contents.strip("students_dict = ")
studentDict = ast.literal_eval(contents)
self.studentQueue = queue.Queue(roster.Roster(studentDict))
with open('queueState.py', 'r') as file:
savedActiveRoster = file.readline().strip("activeRoster = ")
savedPassiveRoster = file.readline().strip("passiveRoster = ")
savedActiveRoster = ast.literal_eval(savedActiveRoster)
savedPassiveRoster = ast.literal_eval(savedPassiveRoster)
if (len(savedActiveRoster) >
0): #if it isn't zero, then there is a saved state.
self.studentQueue.activeRoster = savedActiveRoster
self.studentQueue.passiveRoster = savedPassiveRoster
return
def __init__(self, roster=r.Roster()
): # roster should be a Roster with student information
self.roster = roster
self.activeRoster = [
] # this will be filled with ID numbers of the students. The full information for a student can be found in roster
self.passiveRoster = [
] # once students are cold-called they will be removed from the first list and added to this one. Once it is full it will be randomized
self.numberStudents = 0
self.studentSelected = 0 # when key inputs are received, this number is updated to know which element in the dictionary to remove
rosterKeys = list(roster.student_dict.keys())
random.shuffle(rosterKeys)
for key in rosterKeys:
self.activeRoster.append([
key, self.roster.student_dict[key][2] + " " +
self.roster.student_dict[key][3]
])
self.numberStudents = len(self.activeRoster)
return None
def process_files(self):
##
## ensure the user has selected a hub map file before proceeding
if not self.hub_map_file.get():
print("No directory file selected")
return
else:
hub_map_file = self.hub_map_path + '/' + self.hub_map_file.get()
errata_file = self.hub_map_path + '/' + self.errata_file.get()
##
## ensure the user has selected a directory file before proceeding
if not self.directory_file.get():
print("No directory file selected")
return
else:
directory_file = self.directory_path + '/' + self.directory_file.get(
)
##
## ensure the user has selected a roster file before proceeding
if not self.roster_file.get():
print("No roster file selected")
return
else:
roster_file = self.roster_path + '/' + self.roster_file.get()
##
## process the files
self.hub_map = hub_map_tools.ReadHubMapFromFile(file_name=hub_map_file)
print('Hub map file read complete: ' + hub_map_file)
self.directory = directory_tools.ReadDirectoryFromFile(
file_name=directory_file, hub_map=self.hub_map)
print('Directory file read complete: ' + directory_file)
rosterC = roster.Roster(show_errors='', file_name=errata_file)
self.roster = roster_tools.ReadRosterFromFile(file_name=roster_file,
hub_map=self.hub_map,
rosterC=rosterC)
print('Roster file read complete: ' + roster_file)
##
## now that input files have been read, display the buttons to process them
self.create_user_selection_widgets()
def test_01_with_errata(self):
with patch('builtins.input', side_effect=[None]):
rosterC = roster.Roster()
result = rosterC.ApplyErrata('Name With Error')
self.assertEqual('Name Without Error', result)
def sendPresence(self, jid=None, typ=None, requestRoster=0):
if requestRoster: roster.Roster().PlugIn(self)
self.send(dispatcher.Presence(to=jid, typ=typ))
def getRoster(self):
if not self.__dict__.has_key('Roster'): roster.Roster().PlugIn(self)
return self.Roster.getRoster()
def run_job(job_id):
logger.info("BEGIN JOB: {}".format(job_id))
if job_id == 1:
#Create MFL json
logger.info("BEGIN EXTRACT: PLAYER_DIM")
json_data = mfl.player_dim()
logger.info("END EXTRACT: PLAYER_DIM")
#Create player process object
logger.info("BEGIN TRANSFORM: PLAYER_DIM")
player_load_obj = player_dimension.Player(json_data)
player_load_list = player_load_obj.load_players()
logger.info("END TRANSFORM: PLAYER_DIM")
#Load Player List
logger.info("BEGIN LOAD: PLAYER_DIM")
DB.load_player_dim(player_load_list)
logger.info("END LOAD: PLAYER_DIM")
if job_id == 2:
logger.info("BEGIN EXTRACT: ROSTER")
json_data = mfl.rosters()
logger.info("END EXTRACT: ROSTER")
logger.info("BEGIN TRANSFORM: ROSTER")
current_contracts = DB.current_contracts()
roster_obj = roster.Roster(json_data, current_contracts)
roster_obj.process_rosters()
logger.info("END TRANSFORM: ROSTER")
logger.info("BEGIN LOAD: ROSTER")
DB.load_contracts(roster_obj.contract_updates)
logger.info("END LOAD: ROSTER")
if job_id == 3:
#Create MFL json
logger.info("BEGIN EXTRACT: FACT")
player_scores_json = mfl.player_scores()
weekly_results_json = mfl.weekly_results()
logger.debug(json.dumps(player_scores_json, sort_keys=True, indent=4))
logger.info("EXTRACT: WEEKLY RESULTS")
logger.debug(json.dumps(weekly_results_json, sort_keys=True, indent=4))
logger.info("END EXTRACT: FACT")
#Create fact process Object
logger.info("BEGIN TRANSFORM: FACT")
bdl_fact = BDL_fact.BDL_Fact(player_scores_json, weekly_results_json,
DB.week_id)
bdl_fact.main_process()
logger.info("END TRANSFORM: FACT")
logger.info("BEGIN LOAD: FRANCHISE FACT")
DB.load_franchise_fact(bdl_fact.matchups_to_load)
logger.info("END LOAD: FRANCHISE FACT")
logger.info("BEGIN LOAD: PLAYER FACT")
DB.load_player_fact(bdl_fact.players_to_load)
logger.info("END LOAD: PLAYER FACT")
if job_id == 4:
DB.set_playoffs()
logger.info("END JOB: {}".format(job_id))
def GetResultsUsingInputFile(self, file_name):
with patch('builtins.input', side_effect=[None]):
common_roster = roster.Roster()
roster_file_name = data_file_path + '/' + file_name
return roster_tools.ReadRosterFromFile(roster_file_name,
common_hub_map, common_roster)
import unittest
from unittest.mock import patch, mock_open, call
from unittest.mock import Mock
import os
import person
import family
import roster
import time
##
## Unit Under Test:
import import_file_tools
with patch('builtins.input', side_effect=['y']):
common_RosterC = roster.Roster()
class UT_01_FormTimeTag(unittest.TestCase):
@patch('import_file_tools.localtime')
def test_01_simple(self, mock_localtime):
datetime_str = '2020-01-01-00-00-00'
mock_localtime.return_value = time.strptime(datetime_str,"%Y-%m-%d-%H-%M-%S")
self.assertEqual(datetime_str, import_file_tools.FormTimeTag())
@patch('import_file_tools.localtime')
def test_02_future_date(self, mock_localtime):
datetime_str = '2040-01-01-00-00-00'
mock_localtime.return_value = time.strptime(datetime_str,"%Y-%m-%d-%H-%M-%S")
self.assertEqual(datetime_str, import_file_tools.FormTimeTag())
def getRoster(self):
""" Return the Roster instance, previously plugging it in and
requesting roster from server if needed. """
if not self.__dict__.has_key('Roster'): roster.Roster().PlugIn(self)
return self.Roster.getRoster()
def test_03_show_errors_upper(self):
with patch('builtins.input', side_effect=['Y']):
result = roster.Roster()
self.assertEqual(0, len(result.table))
self.assertFalse(result.hideErrataOutput)
self.assertEqual(1, len(result.errata))
def initRoster(self):
""" Plug in the roster. """
if 'Roster' not in self.__dict__: roster.Roster().PlugIn(self)
def test_02_no_errata(self):
with patch('builtins.input', side_effect=[None]):
rosterC = roster.Roster()
result = rosterC.ApplyErrata('Just Fine Name')
self.assertEqual('Just Fine Name', result)
def sendPresence(self, jid=None, typ=None, requestRoster=0):
""" Send some specific presence state.
Can also request roster from server if according agrument is set."""
if requestRoster: roster.Roster().PlugIn(self)
self.send(dispatcher.Presence(to=jid, typ=typ))
def test_01_do_not_show_errors(self):
with patch('builtins.input', side_effect=[None]):
result = roster.Roster()
self.assertEqual(0, len(result.table))
self.assertTrue(result.hideErrataOutput)
self.assertEqual(1, len(result.errata))
