def trainFromDataFile(): xTrainjson = '/media/jwong/Transcend/VQADataset/TrainSet/XYTrainData/WVsum1000Trainx.json' yTrainjson = '/media/jwong/Transcend/VQADataset/TrainSet/XYTrainData/WVsum1000Trainy.json' xValjson = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/WVsum1000valx.json' yValjson = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/WVsum1000valy.json' xTestjson = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/WVsum1000testx.json' yTestjson = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/WVsum1000testy.json' miniTrainX = '/media/jwong/Transcend/VQADataset/DummySets/miniTrainX.pkl' miniTrainY = '/media/jwong/Transcend/VQADataset/DummySets/miniTrainY.pkl' miniValX = '/media/jwong/Transcend/VQADataset/DummySets/miniValX.pkl' miniValY = '/media/jwong/Transcend/VQADataset/DummySets/miniValY.pkl' xTrainPickle1 = '/media/jwong/Transcend/VQADataset/TrainSet/XYTrainData/WVsum1000Trainx1.pkl' xTrainPickle2 = '/media/jwong/Transcend/VQADataset/TrainSet/XYTrainData/WVsum1000Trainx2.pkl' xTrainPickle3 = '/media/jwong/Transcend/VQADataset/TrainSet/XYTrainData/WVsum1000Trainx3.pkl' yTrainPickle1 = '/media/jwong/Transcend/VQADataset/TrainSet/XYTrainData/WVsum1000Trainy1.pkl' yTrainPickle2 = '/media/jwong/Transcend/VQADataset/TrainSet/XYTrainData/WVsum1000Trainy2.pkl' yTrainPickle3 = '/media/jwong/Transcend/VQADataset/TrainSet/XYTrainData/WVsum1000Trainy3.pkl' xValPickle = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/WVsum1000valx.pkl' yValPickle = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/WVsum1000valy.pkl' xTestPickle = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/WVsum1000testx.pkl' yTestPickle = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/WVsum1000testy.pkl' trainReader = InputReader(xTrainPickle1, yTrainPickle1) valReader = InputReader(xValPickle, yValPickle) model = SoftmaxLayer() model.trainFromFile(trainReader, valReader)
def test_storeInputData(self):
inputReader = InputReader("InputReaderTest.txt")
lines = ['# lijnen die beginnen met # worden genegeerd\n',
'init\n', '# de vervaldatum staat achteraan in '
'het formaat: jaar maand dag\n', 'shot melk 20 2017 3 1\n', 'shot melk 20 2030 5 1\n',
'shot melk 10 2030 6 10\n', 'shot wit 10 2030 5 1\n', 'shot zwart 5 2030 5 1\n',
'shot bruin 20 2030 5 1\n', 'honing 10 2030 5 1\n', 'marshmallow 10 2030 5 1\n',
'chili 5 2030 5 1\n', 'gebruiker Tom Hofkens [email protected]\n',
'gebruiker John Doe [email protected]\n', 'werknemer Wim Hofkens 5\n', 'werknemer Jane Doe 2\n', '\n',
'# start het systeem op\n', 'start\n',
'\n', '# bestel op tijdstip 1 een chocolademelk gemaakt van een melkchocolade shot, '
'chilipeper en een marshmallow\n', '# tijdstip 1 is 1 mei 2018 om 11.30u\n',
'1 bestel [email protected] melk melk melk zwart zwart chili zwart chili marshmallow '
'marshmallow melk 2018 5 1 11 30\n', '\n',
'# bestel op tijdstip 2 een chocolademelk gemaakt '
'van een twee zwarte chocolade shots, chilipeper en een marshmallow\n',
'2 bestel [email protected] zwart chili melk melk melk melk melk melk melk melk melk melk melk melk melk'
' zwart marshmallow 2018 5 1 12 00\n', '\n',
'# bestel eveneens op tijdstip 2 een chocolademelk gemaakt van een melkchocolade shot en een'
' marshmallow\n', '2 bestel [email protected] melk marshmallow melk 2018 5 1 12 00\n', '\n',
'# voeg 4 keer melkchocolade toe aan de stock\n', '3 stock shot melk 4 2018 5 1\n', '\n',
'# dit maakt een bestand log4.html\n', '4 pass\n', '5 pass\n', '6 pass\n', '7 log\n']
inputReader.StoreInputData()
self.assertEqual(inputReader.getLines(), lines)
class Integrals(object):
"""
contains available integration methods
"""
def __init__(self):
"""
creates variables used for reading, parsing and calculating
:return: none
"""
self.reader = InputReader() # reading engine
self.validator = InputValidator() # parsing engine
self.integrator = TrIntegrator() # integration engine
def singleIntegral(self):
"""
calculates single integral provided from console input
:return: list, history of completed calculations
"""
log = [] # create empty log list
while True:
parameters = self.reader.consoleInput() # get data
if len(parameters) > 0: # if there is anything to do
polynomial = eval("lambda x : " + parameters[0]) # create function of provided equation
result = self.integrator.integrate(polynomial, float(parameters[1]), float(parameters[2]), float(parameters[3]) ) # run integration
print("Result: " + str(result))
log.append(str(datetime.now()) + ", Result: " + str(result) + ", W(x)=" + parameters[0] + ', from:' + parameters[1] + ' to:' + parameters[2] + ', step=' + parameters[3]) # add result to log
if len(parameters) > 0 and self.reader.yesNoInput("Would you like to begin new integration?"): # ask user to try again
continue
else:
return log
def manyIntegrals(self):
"""
calculates seres of integrals provided in file
:return: list, history of completed calculations
"""
log = []
while True:
fileContent = self.reader.fileInput() # ask user for input
for line in fileContent: # for each line in file get the parameters
parameters = line[5:]
parameters = parameters.split(' ')
parameters[0] = parameters[0].split(',')[0]
parameters[1] = parameters[1].split(':')[1]
parameters[2] = parameters[2].split(':')[1]
parameters[2] = parameters[2].split(',')[0]
parameters[3] = parameters[3].split('=')[1]
if self.validator.validateParameters(parameters): # parse the parameters
polynomial = eval("lambda x : " + parameters[0]) # create function from equation
result = self.integrator.integrate(polynomial, float(parameters[1]), float(parameters[2]), float(parameters[3]) ) # do th integration
print("Result: " + str(result))
log.append(str(datetime.now()) + ", Result: " + str(result) + ", W(x)=" + parameters[0] + ', from:' + parameters[1] + ' to:' + parameters[2] + ', step=' + parameters[3]) # save to log
else:
print("Error in line: " + "'" + line + "'")
if len(fileContent) > 0 and self.reader.yesNoInput("Would you like to begin new integration?"): # ask user to try again
continue
else:
return log
def main():
inputReader = InputReader(BASE_PATH)
while inputReader.hasNextFile():
fileName = inputReader.getNextFile()
fileProcessor = FileReader(BASE_PATH, fileName)
fileContent = fileProcessor._getFileContent()
htmlParser = HTMLParser(fileContent)
tagContent = htmlParser.getContentFromTags(args.tags)
writeToFile(fileName, tagContent)
def main():
inputReader = InputReader(INPUT_PATH)
while inputReader.hasNextFile():
fileName = inputReader.getNextFile()
fileProcessor = FileReader(INPUT_PATH, fileName)
fileContent = fileProcessor._getFileContent()
sentences = getSentences(fileContent)
for sentence in sentences:
writeFeaturesToFile(sentence, fileName)
break
def main():
inputReader = InputReader(INPUT_PATH)
while inputReader.hasNextFile():
fileName = inputReader.getNextFile()
fileProcessor = FileReader(INPUT_PATH, fileName)
fileContent = fileProcessor._getFileContent()
sentences = getSentences(fileContent)
for sentence in sentences:
writeFeaturesToFile(sentence, fileName)
break
class SupportSystem:
def __init__(self):
self.reader = InputReader()
self.responder = Responder()
def start(self):
finished = False
self.printWelcome()
while not finished:
user_input = self.reader.getInput()
if user_input.startswith('bye'):
finished = True
else:
self.response = self.responder.generateResponder()
print(self.response)
self.printGoodbye()
def printWelcome(self):
print("Welkom bij de immalle helpdienst!")
print("Vertel je probleem...")
print("om te stoppen type 'bye'")
def printGoodbye(self):
print("tot ziens!")
class SupportSystem:
def __init__(self):
self.reader = InputReader()
self.responder = Responder()
def start(self):
finished = False
self.printWelcome()
while not finished:
user_input = self.reader.getInput()
if user_input.startswith('bye'):
finished = True
else:
response = self.responder.generateResponse()
print(response)
self.printGoodBye()
def printWelcome(self):
print("Welkom bij het Immalle helpsysteem, wat is uw probleem?")
print("Typ bye om te stoppen.")
def printGoodBye(self):
print("Tot de volgende.")
class SupportSystem:
def __init__(self):
self.reader = InputReader()
self.responder = Responder()
def start(self):
finished = False
self.printWelcome()
while not finished:
wordset = self.reader.getInput()
if 'bye' in wordset:
finished = True
else:
response = self.responder.generateResponse(wordset)
print(response)
self.printGoodbye()
def printWelcome(self):
print("Welkom bij het immalle helpsysteem...")
print()
print("Vertel ons uw probleem...")
print("Type 'bye' om te stoppen.")
def printGoodbye(self):
print("Tot ziens!")
def get_rain(self):
ir = InputReader()
res = ir.read_analogic_sensor(analog_pin["rain"])
db = DatabaseManager()
if (res > 400):
valDB = db.store_rain(0)
return 0, "no rain"
elif (res > 200 and res <= 400):
valDB = db.store_rain(1)
return 1, "rain"
else:
valDB = db.store_rain(2)
return 2, "heavy rain"
class SupportSystem:
def __init__(self):
self.reader = InputReader()
self.responder = Responder()
def printWelcome(self):
print("welcome to imma tech support sytsem")
print()
print("please tell us about your problem")
print("please type 'bye' to exit the system")
def printGoodbye(self):
print("Nice talking top you. Bye...")
def start(self):
finished = False
self.printWelcome()
while not finished:
user_input = self.reader.getInput()
if user_input.startswith('bye'):
finished = True
else:
response = self.responder.generateResponse
print(response)
self.printGoodbye()
def get_soil_humidity(self):
ir = InputReader()
res = ir.read_analogic_sensor(analog_pin["soil_humidity"])
db = DatabaseManager()
if (res <= 200):
valDB = db.store_moisture(0)
return 0
elif (res >= 510):
valDB = db.store_moisture(100)
return 100
else:
temp = (10 * res - 2000) / 31
valDB = db.store_moisture(int(temp))
return int(temp)
class SupportSystem:
def __init__(self):
self.reader = InputReader()
self.responder = Responder()
def start(self):
finished = False
self.printWelkom()
while not finished:
user_input = self.reader.getInput().lower()
if user_input.startswith('bye'):
finished = True
else:
response = self.responder.generateResponse()
print(response)
self.printGoodbye()
def printWelkom(self):
print("Welkom bij het immalle helpsysteem")
print()
print("Vertel ons uw probleem...")
print("Typer 'bye' om te stoppen")
def printGoodbye(self):
print("Goodbye!")
def test():
xTestPickle = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/sparseCleanWVsum1000testx.pkl'
yTestPickle = '/media/jwong/Transcend/VQADataset/ValTestSet/XYValTestData/sparseCleanWVsum1000testy.pkl'
testReader = InputReader(xTestPickle, yTestPickle)
model = SoftmaxLayer()
model.testSavedModel(testReader)
def __init__(self):
"""
creates variables used for reading, parsing and calculating
:return: none
"""
self.reader = InputReader() # reading engine
self.validator = InputValidator() # parsing engine
self.integrator = TrIntegrator() # integration engine
def __init__(self, filename):
reader = InputReader()
self.poly = reader.load(filename)
self.start = self.poly.pop(0)
self.end = self.poly.pop(0)
print "Following polynomial was loaded: "
counter = 0
for i in self.poly:
if counter == 0:
sys.stdout.write(str(i))
elif counter == 1:
sys.stdout.write(" + " + str(i) + 'x')
else:
sys.stdout.write(" + " + str(i) + 'x^' + str(counter))
counter += 1
sys.stdout.write("\n")
print 'Integral calculation starts:', self.start, 'ends:', self.end
def test_inputFileToCommands(self):
inputReader = InputReader("InputReaderTest.txt")
commands = ['init', 'shot', 'melk', '20', '2017', '3', '1', 'shot', 'melk', '20', '2030', '5', '1', 'shot',
'melk', '10', '2030', '6', '10', 'shot', 'wit', '10', '2030', '5', '1', 'shot', 'zwart', '5',
'2030', '5', '1', 'shot', 'bruin', '20', '2030', '5', '1', 'honing', '10', '2030', '5', '1',
'marshmallow', '10', '2030', '5', '1', 'chili', '5', '2030', '5', '1', 'gebruiker', 'Tom',
'Hofkens', '*****@*****.**', 'gebruiker', 'John', 'Doe', '*****@*****.**', 'werknemer',
'Wim', 'Hofkens', '5', 'werknemer', 'Jane', 'Doe', '2', 'start', '1', 'bestel',
'*****@*****.**', 'melk', 'melk', 'melk', 'zwart', 'zwart', 'chili', 'zwart', 'chili',
'marshmallow', 'marshmallow', 'melk', '2018', '5', '1', '11', '30', '2', 'bestel', '*****@*****.**',
'zwart', 'chili', 'melk', 'melk', 'melk', 'melk', 'melk', 'melk', 'melk', 'melk', 'melk', 'melk',
'melk', 'melk', 'melk', 'zwart', 'marshmallow', '2018', '5', '1', '12', '00', '2', 'bestel',
'*****@*****.**', 'melk', 'marshmallow', 'melk', '2018', '5', '1', '12', '00', '3',
'stock', 'shot', 'melk', '4', '2018', '5', '1', '4', 'pass', '5', 'pass', '6', 'pass', '7', 'log']
inputReader.StoreInputData()
inputReader.InputFileToCommands()
self.assertEqual(inputReader.getCommands(), commands)
def get_light(self):
ir = InputReader()
res = ir.read_analogic_sensor(analog_pin["light"])
db = DatabaseManager()
if (res <= 200):
valDB = db.store_light(0)
return 0, "Dark"
elif (res > 200 and res <= 400):
valDB = db.store_light(1)
return 1, "Dim" #shadow
elif (res > 400 and res <= 700):
valDB = db.store_light(2)
return 2, "Light"
elif (res > 700 and res <= 900):
valDB = db.store_light(3)
return 3, "Bright"
else:
valDB = db.store_light(4)
return 4, "Very Bright"
def main(arguments):
"""
Main-Methode zum Steuern von Input, Berechnung und Output
"""
main = Main()
#check arguments and initialize variables of main
try:
main.iterationen = arguments.iterationen
if main.iterationen <= 0:
raise ArithmeticError(
"Error. Also, 0 oder weniger Iterationen sind wirklich nicht moeglich. Zeitreisen wurde noch nicht implementiert."
)
if arguments.input == None:
main.printUsage()
return 0
if arguments.skalierungsfaktor < 0:
raise ArithmeticError("Error. Der Faktor muss groesser 0 sein.")
if arguments.output == None:
main.mFilename = re.sub("[.]txt", "", arguments.input)
else:
main.mFilename = arguments.output
except ArithmeticError as err:
sys.stderr.write(str(err))
return 1
main.mInput = InputReader(arguments.input)
#read input
main.karte = main.mInput.read()
if (main.karte == None): #input file has semantic issues
return 1
karte = main.karte
main.mBerechnung = StandardBerechnung()
stepsize = 0.1 * main.iterationen
for i in range(main.iterationen):
if (i == 0):
print("Berechne Voriteration")
main.mBerechnung.voriteration(karte, arguments.skalierungsfaktor)
if i % stepsize == 0:
print("" + str(i) + " Iterationen")
karte = main.mBerechnung.berechne(karte)
karte.berechneMinimum()
karte.scale()
if (main.mFilename == "<default>"):
main.mFilename = arguments.input.split(".")[0]
main.mOutput = OutputWriter(main.mFilename, "templates/template.txt",
main.karte, main.iterationen)
main.mOutput.write()
print("Beendet nach " + str(main.iterationen) + " Iterationen")
return 0
def create_trees(trees):
# get the input mc files and their metadata
data_dir = '/Volumes/BlackArmor Drive/Data/CompressedSpectra/' + \
'monte_carlo/signal_grids/GO_decoupledSQ_13TeV/'
mcfile_list = data_dir+'scan_summary.dat'
reader = InputReader(mcfile_list)
reader.process_file()
# create the signal grid
if make_signal_grid:
signal_grid = ([],[])
for mcfile in reader.mcfiles:
signal_grid[0].append(mcfile.mGO) # gluino mass
signal_grid[1].append(mcfile.mN1) # neutralino mass
# fill TGraph (x=mGO, y=mN1)
sgrid = ru.create_tgraph(signal_grid[0], signal_grid[1])
sgrid.GetXaxis().SetTitle('m_{g}')
sgrid.GetYaxis().SetTitle('m_{#chi}')
# draw signal grid
canvas = TCanvas()
sgrid.Draw('AP')
canvas.SaveAs('./output/signal_grid.pdf')
# create a single chain with all of the mc events
for mcfile in reader.mcfiles:
chain = TChain('Delphes')
data_file = data_dir+'Decayed/Events/'+mcfile.file_prefix+'.Delphes3.root'
chain.Add(data_file)
trees.append( (mcfile,chain) )
# create the output directory structure as well
outdir = './output/mGO_%s_mN1_%s' %(mcfile.mGO, mcfile.mN1)
create_directory(outdir)
def get_current_best_score():
best_scores = {}
for output_filename in os.listdir(OUTPUT_DIRECTORY):
# Read input
input_filename = '%s.txt' % os.path.splitext(output_filename)[0]
reader = InputReader(os.path.join(INPUT_DIRECTORY, input_filename))
pics = reader.photos
try:
# Retrieve output
with open(os.path.join(OUTPUT_DIRECTORY, output_filename)) as f:
header = f.readline()
output = []
for line in f.readlines():
line = line.strip()
if line:
pic_1_2 = line.split(' ')
pic_1 = pics[int(pic_1_2[0])]
if len(pic_1_2) > 1:
pic_2 = pics[int(pic_1_2[1])]
else:
pic_2 = None
output.append(Slide(pic_1, pic_2))
# Score solution
current_score = slideshow_score(output)
except KeyError:
current_score = -1
best_scores[input_filename] = current_score
return best_scores
def __init__(self):
self.__store = Store()
self.__logOut = LogOutput()
self.__inputReader = InputReader("system.txt")
self.__inputReader.StoreInputData()
self.__inputReader.InputFileToCommands()
def __init__(self):
self.reader = InputReader()
self.responder = Responder()
train_op = tf.train.AdamOptimizer(learning_rate=learningRate).minimize(cost)
# Evaluate
correct_pred = tf.equal(tf.argmax(logits, 2), tf.argmax(y, 2))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
'''Model save'''
# Initialize the saver to save session.
saver = tf.train.Saver(write_version=tf.train.SaverDef.V1, max_to_keep=50)
saved_model_path = 'model/'
to_save_model_path = 'model/'
'''Start a session and run up.'''
with tf.Session(config=config) as sess:
logging.info("Session started!")
sess.run(tf.global_variables_initializer())
# Prepare data set.
dataSet = InputReader(dataFile, batchSize, timestepSize)
# Prepare result writer.
resultWriter = ResultWriter(resultFile)
for i in range(iteration):
(batchX, batchY) = dataSet.getBatch(i)
_, trainingCost, modelOutput = sess.run([train_op, cost, logits],
feed_dict={
X: batchX,
y: batchY,
keep_prob: 1.0
})
logging.info("Iteration:" + str(i) +
", \tbatch loss= {:.6f}".format(trainingCost))
logging.debug("batchX:" + str(batchX[0]))
logging.debug("batchY:" + str(batchY[0]))
logging.debug("modelOutput:" + str(modelOutput[0]))
from Menu import Menu
from Integrals import Integrals
from History import History
from InputReader import InputReader
from Help import Help
# creating necessary objects
log = History()
menu = Menu()
reader = InputReader()
sub = Integrals()
myHelp = Help()
while True:
selection = menu.select() #
if selection == 'q': # Quiting the main menu
break
elif selection == '1': # choosing single integral option
result = sub.singleIntegral()
log.add(result)
elif selection == '2': # choosing many integrals
results = sub.manyIntegrals()
log.add(results)
elif selection == '3': # choosing history
log.show()
raw_input("Press any key to close...")
elif selection == '4': # choosing help
myHelp.show()
raw_input("Press any key to close...")
sendLock = Lock()
inLonck = Lock()
sender = Sender(sock, sendLock)
receiver = Receiver(chatIp, chatPort, False, sender, settings['username'][0])
if (not receiver.start(sock)):
sys.stderr.write('Unable to start peer at adress ' + chatIp +
' and port ' + str(chatPort) + '\n')
exit(invalid_arguments)
# udrzeni spojeni s uzlem
keeper = ConnectionKeeper()
keeper.hello(sender, settings['username'][0], chatIp, chatPort, regIp, regPort)
# nacitani prikazu od rpc a uzivatele
filename = '.' + settings['id'][0] + '.peercommands'
reader = InputReader(filename, settings['username'][0])
def thisIsTheEnd(_, __):
keeper.stop()
reader.stop()
exit(0)
signal.signal(signal.SIGINT, thisIsTheEnd)
signal.signal(signal.SIGTERM, thisIsTheEnd)
while True:
# ceka na prikazy
reader.wait()
# zpracovava jednotlive prikazy
best_mean_score = mean / 3
max_score = best_mean_score * count
with open(filename, 'w') as f:
f.write('%s %s %s %s\n' %
(mean, std_dev, best_mean_score, max_score))
for tag, count in sorted(counter.most_common(),
key=lambda x: x[0]):
f.write('%s %s\n' % (tag, count))
# Get input file from command line arg list
input_file = sys.argv[1]
file_path = os.path.join(INPUT_DIRECTORY, input_file)
assert os.path.exists(file_path)
# Get objects from input file
inputReader = InputReader(file_path)
occurrences = []
for i, pic in inputReader.photos.items():
occurrences.append(len(pic.tags))
counter = Counter(occurrences)
# Save result to output file
output_file = os.path.splitext(input_file)[0] + '.count'
out_path = os.path.join(DESC_DIRECTORY, output_file)
write_desc(counter, out_path)
#inputReader = InputReader()
#inputReader.readData()
#Data.Q = [[0 for i in range(2)] for i in range(3)]
#print (Constants.timeVsTechnologyHeader)
''' ==================================== '''
print "Program execution started..."
''' Validate the configuration for the program'''
validator = Validator()
if validator.validateConfig() == False:
exit(1)
''' Read input directory and create data file '''
inputReader = InputReader()
inputReader.readPortfolioFile()
for portfolio in Data.portfolios:
logging.debug("Started Processing Portfolio"+ portfolio.name)
Config.inputFileDirectory = portfolio.inputDirectory
inputReader.readData()
''' Calculate W for the portfolio '''
calculator = Calculator()
totalWForPortfolio = calculator.calculateWForPortfolio(0)
portfolio.setTotalW(totalWForPortfolio)
outputWriter = OutputWriter()
portfolioOutputDirectory = Config.outputFileDirectory + "/" + portfolio.name
if not os.path.exists(portfolioOutputDirectory):
# Prijem a odesilani zprav
sock = socket.socket( socket.AF_INET, socket.SOCK_DGRAM )
lock = Lock()
sender = Sender( sock, lock )
receiver = Receiver( regIp, regPort, True, sender )
if ( not receiver.start( sock ) ):
sys.stderr.write( 'Unable to start node at adress ' + regIp + ' and port ' + str(regPort) + '\n' )
exit( invalid_arguments )
# Pravidelne odesilani update
keeper = ConnectionKeeper()
keeper.update( receiver )
# Zpracovani prikazu od uzivatele a rpc
filename = '.' + settings[ 'id' ][0] + '.nodecommands'
reader = InputReader( filename )
def thisIsTheEnd( _, __ ):
keeper.stop()
reader.stop()
exit( 0 )
signal.signal( signal.SIGINT, thisIsTheEnd)
signal.signal( signal.SIGTERM, thisIsTheEnd)
while True:
# cekam na prikazy
reader.wait()
# zpracovavam vsechny nove prikazy
for cmd in reader:
if cmd[ 'type' ] == 'error' and 'verbose' in cmd:
def test_inputReader(self):
inputReader = InputReader("InputReaderTest.txt")
self.assertIsNone(inputReader.getFile())
self.assertIsNone(inputReader.getLines())
self.assertIsNone(inputReader.getCommands())
self.assertEqual(inputReader.getFileName(), "InputReaderTest.txt")
def main():
dummySetDirX = '/media/jwong/Transcend/VQADataset/DummySets/DummySparseCleanWVsum1000Trainx.pkl'
dummySetDirY = '/media/jwong/Transcend/VQADataset/DummySets/DummySparseCleanWVsum1000Trainy.pkl'
trainReader = InputReader(dummySetDirX, dummySetDirY)
class StoreSimulator:
def __init__(self):
self.__store = Store()
self.__logOut = LogOutput()
self.__inputReader = InputReader("system.txt")
self.__inputReader.StoreInputData()
self.__inputReader.InputFileToCommands()
def initialise(self):
i = 0
while i != len(self.__inputReader.getCommands()):
if self.__inputReader.getCommands()[i] == "init":
i += 1
self.__store.createStore()
continue
if self.__inputReader.getCommands()[i] == "start":
i += 1
return i
if self.__inputReader.getCommands()[i] == "shot":
i += 1
shotType = self.__inputReader.getCommands()[i]
i += 1
amount = self.__inputReader.getCommands()[i]
i += 1
year = self.__inputReader.getCommands()[i]
i += 1
month = self.__inputReader.getCommands()[i]
i += 1
day = self.__inputReader.getCommands()[i]
i += 1
if shotType == "melk":
for j in range(0, int(amount)):
self.__store.restockMilkChocolateShot(
int(year + month + day))
continue
elif shotType == "wit":
for j in range(0, int(amount)):
self.__store.restockWhiteChocolateShot(
int(year + month + day))
continue
elif shotType == "zwart":
for j in range(0, int(amount)):
self.__store.restockDarkChocolateShot(
int(year + month + day))
continue
elif shotType == "bruin":
for j in range(0, int(amount)):
self.__store.restockBrownChocolateShot(
int(year + month + day))
continue
return False
if self.__inputReader.getCommands()[i] == "honing":
i += 1
amount = self.__inputReader.getCommands()[i]
i += 1
year = self.__inputReader.getCommands()[i]
i += 1
month = self.__inputReader.getCommands()[i]
i += 1
day = self.__inputReader.getCommands()[i]
i += 1
for j in range(0, int(amount)):
self.__store.restockHoney(int(year + month + day))
continue
if self.__inputReader.getCommands()[i] == "marshmallow":
i += 1
amount = self.__inputReader.getCommands()[i]
i += 1
year = self.__inputReader.getCommands()[i]
i += 1
month = self.__inputReader.getCommands()[i]
i += 1
day = self.__inputReader.getCommands()[i]
i += 1
for j in range(0, int(amount)):
self.__store.restockMarshmallow(int(year + month + day))
continue
if self.__inputReader.getCommands()[i] == "chili":
i += 1
amount = self.__inputReader.getCommands()[i]
i += 1
year = self.__inputReader.getCommands()[i]
i += 1
month = self.__inputReader.getCommands()[i]
i += 1
day = self.__inputReader.getCommands()[i]
i += 1
for j in range(0, int(amount)):
self.__store.restockChilipepper(int(year + month + day))
continue
if self.__inputReader.getCommands()[i] == "gebruiker":
i += 1
firstName = self.__inputReader.getCommands()[i]
i += 1
lastName = self.__inputReader.getCommands()[i]
i += 1
email = self.__inputReader.getCommands()[i]
i += 1
self.__store.addUser(firstName, lastName, email)
continue
if self.__inputReader.getCommands()[i] == "werknemer":
i += 1
firstName = self.__inputReader.getCommands()[i]
i += 1
lastName = self.__inputReader.getCommands()[i]
i += 1
workLoad = self.__inputReader.getCommands()[i]
i += 1
self.__store.addWorker(firstName, lastName, int(workLoad))
continue
return
def simulate(self, i):
self.__logOut.addRow(self.__store, self.__store.getTime())
while i != len(self.__inputReader.getCommands()):
if self.__inputReader.getCommands()[i] == str(
self.__store.getTime() + 1):
self.__logOut.addRow(self.__store, self.__store.getTime())
self.__store.work()
workersCopy = copy.deepcopy(self.__store.getWorkers())
while not workersCopy.isEmpty():
worker = workersCopy.retrieve(None)
workersCopy.delete(None)
self.__store.tick()
i += 1
continue
if self.__inputReader.getCommands()[i] == str(
self.__store.getTime()):
i += 1
continue
if self.__inputReader.getCommands()[i] == "bestel":
i += 1
email = self.__inputReader.getCommands()[i]
i += 1
user = self.__store.getUser(email)
user.createOrder(self.__store.getChocolateMilkCount())
while (self.__inputReader.getCommands()[i] == "melk"
or self.__inputReader.getCommands()[i] == "wit"
or self.__inputReader.getCommands()[i] == "zwart"
or self.__inputReader.getCommands()[i] == "bruin"
or self.__inputReader.getCommands()[i] == "marshmallow"
or self.__inputReader.getCommands()[i] == "chili"
or self.__inputReader.getCommands()[i] == "honey"):
if self.__inputReader.getCommands()[i] == "melk":
user.addMilkChocolateShot()
elif self.__inputReader.getCommands()[i] == "wit":
user.addWhiteChocolateShot()
elif self.__inputReader.getCommands()[i] == "zwart":
user.addDarkChocolateShot()
elif self.__inputReader.getCommands()[i] == "bruin":
user.addBrownChocolateShot()
elif self.__inputReader.getCommands()[i] == "marshmallow":
user.addMarshmallow()
elif self.__inputReader.getCommands()[i] == "chili":
user.addChilipepper()
elif self.__inputReader.getCommands()[i] == "honey":
user.addHoney()
i += 1
year = self.__inputReader.getCommands()[i]
i += 1
month = self.__inputReader.getCommands()[i]
i += 1
day = self.__inputReader.getCommands()[i]
i += 1
hour = self.__inputReader.getCommands()[i]
i += 1
minute = self.__inputReader.getCommands()[i]
i += 1
user.getCurrentOrder().setTimeStamp(
int(year + month + day + hour + minute))
if self.__store.addChocolateMilk(
user.getChocolateMilk(), user.getCurrentOrder(),
int(year + month + day),
int(year + month + day + hour + minute)):
user.setChocolateMilk(None)
user.setCurrentOrder(None)
if self.__inputReader.getCommands()[i] == "stock":
i += 1
if self.__inputReader.getCommands()[i] == "shot":
i += 1
shotType = self.__inputReader.getCommands()[i]
i += 1
amount = self.__inputReader.getCommands()[i]
i += 1
year = self.__inputReader.getCommands()[i]
i += 1
month = self.__inputReader.getCommands()[i]
i += 1
day = self.__inputReader.getCommands()[i]
i += 1
if shotType == "melk":
for j in range(0, int(amount)):
self.__store.restockMilkChocolateShot(
int(year + month + day))
continue
elif shotType == "wit":
for j in range(0, int(amount)):
self.__store.restockWhiteChocolateShot(
int(year + month + day))
continue
elif shotType == "zwart":
for j in range(0, int(amount)):
self.__store.restockDarkChocolateShot(
int(year + month + day))
continue
elif shotType == "bruin":
for j in range(0, int(amount)):
self.__store.restockBrownChocolateShot(
int(year + month + day))
continue
return False
if self.__inputReader.getCommands()[i] == "honing":
i += 1
amount = self.__inputReader.getCommands()[i]
i += 1
year = self.__inputReader.getCommands()[i]
i += 1
month = self.__inputReader.getCommands()[i]
i += 1
day = self.__inputReader.getCommands()[i]
i += 1
for j in range(0, int(amount)):
self.__store.restockHoney(int(year + month + day))
continue
if self.__inputReader.getCommands()[i] == "marshmallow":
i += 1
amount = self.__inputReader.getCommands()[i]
i += 1
year = self.__inputReader.getCommands()[i]
i += 1
month = self.__inputReader.getCommands()[i]
i += 1
day = self.__inputReader.getCommands()[i]
i += 1
for j in range(0, int(amount)):
self.__store.restockMarshmallow(int(year + month +
day))
continue
if self.__inputReader.getCommands()[i] == "chili":
i += 1
amount = self.__inputReader.getCommands()[i]
i += 1
year = self.__inputReader.getCommands()[i]
i += 1
month = self.__inputReader.getCommands()[i]
i += 1
day = self.__inputReader.getCommands()[i]
i += 1
for j in range(0, int(amount)):
self.__store.restockChilipepper(int(year + month +
day))
continue
if self.__inputReader.getCommands()[i] == "log":
self.__logOut.addRow(self.__store, self.__store.getTime())
self.__logOut.writeHtml()
return
if self.__inputReader.getCommands()[i] == "pass":
i += 1
continue
return
# remove double breakspaces in the string and breakspace(s) in the begining of the string
def remove_redundant_breakspaces(string_curr):
string_prev = ""
while string_prev != string_curr:
string_prev = string_curr
string_curr = string_curr.replace(' ', '') # remove all breakspaces in the string
string_curr = string_curr.replace('q', ' q') # add one breakspace before each 'q' char
string_curr = string_curr.replace(' ', '', 1) # remove one breakspace in the begining of the string
return string_curr
if __name__ == "__main__":
input_file_name = "input.txt"
input_reader = InputReader(input_file_name)
output_writer = OutputWriter()
reg_exp = input_reader.read_one_line()
ndfsa = Parser.reg_exp_parse(reg_exp)
test_cases_list = input_reader.read_test_cases_from_input_file()
for j in range(len(test_cases_list)):
result_string = ""
result = ndfsa.validate(test_cases_list[j])
if not result: # for cases: result = False
result = ""
if j != len(test_cases_list) - 1:
class ADTSimulator:
def __init__(self):
self.__inputReader = InputReader("adt.txt")
self.__inputReader.StoreInputData()
self.__inputReader.InputFileToCommands()
self.__Wrapper = None
def runADTSimulation(self):
i = 0
newItem = False
searchkey = False
while i != len(self.__inputReader.getCommands()):
print(self.__inputReader.getCommands()[i])
if self.__inputReader.getCommands()[i] == "type=bst":
self.__Wrapper = BSTWrapper()
self.__Wrapper.create()
newItem = False
searchkey = True
i += 1
elif self.__inputReader.getCommands()[i] == "type=stack":
self.__Wrapper = StackWrapper()
self.__Wrapper.create()
newItem = True
searchkey = False
i += 1
elif self.__inputReader.getCommands()[i] == "type=queue":
self.__Wrapper = QueueWrapper()
self.__Wrapper.create()
newItem = True
searchkey = False
i += 1
elif self.__inputReader.getCommands()[i] == "type=dll":
self.__Wrapper = DLCWrapper()
self.__Wrapper.create()
newItem = False
searchkey = True
i += 1
elif self.__inputReader.getCommands()[i] == "type=cll":
self.__Wrapper = CLCWrapper()
self.__Wrapper.create()
newItem = False
searchkey = True
i += 1
elif self.__inputReader.getCommands()[i] == "type=hlin":
self.__Wrapper = HLinWrapper()
self.__Wrapper.create()
newItem = False
searchkey = True
i += 1
elif self.__inputReader.getCommands()[i] == "type=hquad":
self.__Wrapper = HQuadWrapper()
self.__Wrapper.create()
newItem = False
searchkey = True
i += 1
elif self.__inputReader.getCommands()[i] == "type=hsep":
self.__Wrapper = HSepWrapper()
self.__Wrapper.create()
newItem = False
searchkey = True
i += 1
elif self.__inputReader.getCommands()[i] == "type=23":
self.__Wrapper = TwoThreeWrapper()
self.__Wrapper.create()
newItem = False
searchkey = True
i += 1
elif self.__inputReader.getCommands()[i] == "insert":
i += 1
if not newItem:
self.__Wrapper.insert(
int(self.__inputReader.getCommands()[i]), None)
elif not searchkey:
self.__Wrapper.insert(
None, int(self.__inputReader.getCommands()[i]))
i += 1
elif self.__inputReader.getCommands()[i] == "delete":
i += 1
if not searchkey:
self.__Wrapper.delete(None)
else:
self.__Wrapper.delete(
int(self.__inputReader.getCommands()[i]))
i += 1
elif self.__inputReader.getCommands()[i] == "print":
self.__Wrapper.print()
i += 1
return
def __init__(self):
self.__inputReader = InputReader("adt.txt")
self.__inputReader.StoreInputData()
self.__inputReader.InputFileToCommands()
self.__Wrapper = None
