class InputReader(object):
"""
contains user input methods
"""
def __init__(self):
"""
:return:
"""
self.validator = InputValidator() # initialize the validating engine
def consoleInput(self):
"""
terminal input method
:return: list of parameters
"""
while True:
usrInput = raw_input("Please provide: polynomial,min,max,step:")
usrInput = usrInput[5:].split(',') # splitting different parameters
if self.validator.validateParameters(usrInput): # run the validation
return usrInput
elif self.yesNoInput("Try again?"): # if validation fails, ask to try again
continue
else:
return []
def fileInput(self):
"""
reading from file method
:return:
"""
while True:
fileName = raw_input("Please enter name of the file: ")
if self.validator.validateFile(fileName): # run the validation
with open(fileName, 'r') as f: # open file
fileContent = f.readlines() # read the contents
return fileContent
elif self.yesNoInput("Try again?"): # if validation fails, ask to try again
continue
else:
return []
def yesNoInput(self, string):
"""
simple user decision
:param string: question displayed
:return: bool: true or false
"""
while True :
usrAction = raw_input(string + " y/n:")
if usrAction == 'y':
return True
elif usrAction == 'n':
return False
else:
print("Cannot Recognize command")
def testIndexes(self):
assert InputValidator.input_indexes_are_valid(
Utils.parse_testing_int_list([2, 2])) == True
assert InputValidator.input_indexes_are_valid(
Utils.parse_testing_int_list([3, 4])) == False
assert InputValidator.input_indexes_are_valid(
Utils.parse_testing_int_list([1, 3])) == False
assert InputValidator.input_indexes_are_valid(
Utils.parse_testing_int_list([5, 3])) == False
assert InputValidator.input_indexes_are_valid(
Utils.parse_testing_int_list([0, 0])) == True
def interpret(self, command):
command_arr = command.split()
if InputValidator.validate_command(command_arr):
self.command_dict[command_arr[0]](command_arr)
return 'That was correct format'
else:
return 'that wasnt the correct format'
def prepare_loaded_data(self, file_name):
"""
Przygotowuje i wczytuje dane z pliku
:param file_name: plik z danymi
:return:
"""
#utworzenie bufora
buff = Buffer()
data = CsvReader.read_from_file(file_name, 1)
#zmiana czasu
data = DataOperation.change_time_relative(data)
#zmiana wysokosci na metry
data = DataOperation.change_altitude_cm_m(data)
#stworzenie zapisywacza
saver = FileSaver("saved_data/dane.txt")
#kazda linijke z pliku csv buforujemy osobno
for d in data:
buff.set_data(d)
buffered_data = buff.get_data()
#sprawdzamy czy kazda linijka jest poprawnie zapisana
if InputValidator.input_val(buffered_data):
#zapisujemy kazda linijke do nowego pliku
saver.save_data(buffered_data)
#odczyt danych z pliku csv i wizualizacja
r_data = CsvReader.read_from_file(saver.get_file_name())
#tworzymy wizualizator, drugi parametr do interwal czasowy
self.visualizer = PlotCreator(r_data, 1)
self.data_loaded = True
print "Dane zaladowane"
def prepare_loaded_data(self, file_name):
"""
Przygotowuje i wczytuje dane z pliku
:param file_name: plik z danymi
:return:
"""
#utworzenie bufora
buff = Buffer()
data = CsvReader.read_from_file(file_name, 1)
#zmiana czasu
data = DataOperation.change_time_relative(data)
#zmiana wysokosci na metry
data = DataOperation.change_altitude_cm_m(data)
#stworzenie zapisywacza
saver = FileSaver("saved_data/dane.txt")
#kazda linijke z pliku csv buforujemy osobno
for d in data:
buff.set_data(d)
buffered_data = buff.get_data()
#sprawdzamy czy kazda linijka jest poprawnie zapisana
if InputValidator.input_val(buffered_data):
#zapisujemy kazda linijke do nowego pliku
saver.save_data(buffered_data)
#odczyt danych z pliku csv i wizualizacja
r_data = CsvReader.read_from_file(saver.get_file_name())
#tworzymy wizualizator, drugi parametr do interwal czasowy
self.visualizer = PlotCreator(r_data, 1)
self.data_loaded = True
print "Dane zaladowane"
def testMatrixSpotIsValid(self):
user_input = Utils.parse_testing_int_list([1, 1])
matrix = [
list(EMPTY_SPOT_VALUE * 3), ['?', 'x', '?'],
list(EMPTY_SPOT_VALUE * 3)
]
assert InputValidator.matrix_index_is_not_taken(user_input,
matrix) is False
user_input = Utils.parse_testing_int_list([0, 0])
assert InputValidator.matrix_index_is_not_taken(user_input,
matrix) is True
user_input = Utils.parse_testing_int_list([2, 1])
assert InputValidator.matrix_index_is_not_taken(user_input,
matrix) is True
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
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 client(connection):
while True:
connection.send("Names: ")
names = connection.recv(1024)
verifier = InputValidator()
if(verifier.validate(names)):
names = sub(r'\s+', '', names)
name1,name2 = names.lower().split(",")
if(choice == "1"):
flame = FlamesCalculator(name1, name2)
connection.send(flame.output() + "\nPress enter to continue")
elif(choice == "2"):
trueLove = TrueLoveCalculator(name1, name2)
connection.send(trueLove.output() + "\nPress enter to continue")
else:
connection.send("Invalid Input" + "\nPress enter to continue")
file_name = raw_input("Podaj nazwe pliku z danymi w formacie csv \n")
#wczytanie danych z pliku csv
data = CsvReader.read_from_file(file_name, 1)
#zmiana czasu
data = DataOperation.change_time_relative(data)
#zmiana wysokosci na metry
data = DataOperation.change_altitude_cm_m(data)
#stworzenie zapisywacza
saver = FileSaver("saved_data/dane.txt")
#kazda linijke z pliku csv buforujemy osobno
for d in data:
buff.set_data(d)
buffered_data = buff.get_data()
#sprawdzamy czy kazda linijka jest poprawnie zapisana
if InputValidator.input_val(buffered_data):
#zapisujemy kazda linijke do nowego pliku
saver.save_data(buffered_data)
#odczyt danych z pliku csv i wizualizacja
r_data = CsvReader.read_from_file(saver.get_file_name())
#tworzymy wizualizator, drugi parametr do interwal czasowy
visualizer = PlotCreator(r_data, 1)
fig = visualizer.acceleration_time(True)
#visualizer.speed_time()
#visualizer.dst_time()
#visualizer.dst_accu_time()
#visualizer.altitude_time()
#visualizer.position_time()
#visualizer.pitch_time()
def get_player_input(matrix):
selected_indexes = []
while len(selected_indexes) == 0:
selected_indexes = InputValidator.validate_input(matrix)
return selected_indexes
import pytest
import sys
import os
THIS_FOLDER = os.path.dirname(os.path.abspath(__file__))
sys.path.append(THIS_FOLDER + '/../src/database-layer')
sys.path.append(THIS_FOLDER + '/../src/domain-layer/utilities')
sys.path.append(THIS_FOLDER + '/../src/domain-layer/models')
sys.path.append(THIS_FOLDER + '/../src/domain-layer/handlers')
from InputValidator import InputValidator
from DatabaseAccessor import DatabaseAccessor
from User import User
inputValidator = InputValidator()
DBA = DatabaseAccessor()
def getUser(email, textPassword):
user = User(email, textPassword)
user.encryptAndSetPassword()
user.generateAndSetUserId()
return user
def test_checkInputNull():
assert inputValidator.checkInputNull(None, None) == "email null"
assert inputValidator.checkInputNull(None, 'password123') == "email null"
assert inputValidator.checkInputNull('email123', None) == "password null"
assert inputValidator.checkInputNull(
'email123', 'password123') == "email & password not null"
def __init__(self):
"""
:return:
"""
self.validator = InputValidator() # initialize the validating engine