def recipe(term=None):
silliness = request.args.get('silliness', 50)
source = AllRecipesSource()
intermediates = list(source.search(term))
working = Recipe(term, [], [])
recipe = average(intermediates, working, silliness=float(silliness) / 100)
resp = make_response(render_template('recipe.json', title=recipe.title, ingredients=recipe.ingredients, method=recipe.method))
resp.mimetype = 'application/json'
return resp
def plotData (self):
import matplotlib.pyplot as plt
import average
data_array=average.average(self.data)
#print data_array
tag_array=average.getTag(self.data)
plt.xlabel(tag_array)
plt.plot(range(len(data_array)),data_array)
plt.grid(True)
plt.title('Average Amount for each sub-category')
plt.show()
def test_negitive():
items = [-50, 50]
assert average.average(items) == 0
def test_full():
items = []
with pytest.raises(ValueError):
average.average(items)
import average
import createMask
import time
import os, sys
init = time.time()
class HiddenPrints:
def __enter__(self):
self._original_stdout = sys.stdout
sys.stdout = open(os.devnull, 'w')
def __exit__(self, exc_type, exc_val, exc_tb):
sys.stdout.close()
sys.stdout = self._original_stdout
with HiddenPrints():
average.average()
createMask.createMask()
print("Completed in {} seconds".format(round(time.time() - init)))
def test_average_basic_2(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result)
def do_run_pipeline(name, basedir):
if name[0] != 'P' and name[0] != 'L':
die('This code should be used only with field or observation names',
database=False)
do_field = (name[0] == 'P')
try:
qsubfile = sys.argv[2]
except:
qsubfile = '/home/mjh/pipeline-master/ddf-pipeline/torque/pipeline.qsub'
workdir = basedir + '/' + name
try:
os.mkdir(workdir)
except OSError:
warn('Working directory already exists')
report('Downloading data')
if do_field:
success = download_field(name, basedir=basedir)
else:
success = download_dataset('https://lofar-webdav.grid.sara.nl',
'/SKSP/' + name + '/',
basedir=basedir)
if not success:
die('Download failed, see earlier errors', database=False)
report('Unpacking data')
try:
unpack(workdir=workdir)
except RuntimeError:
if do_field:
update_status(name, 'List failed', workdir=workdir)
raise
if do_field:
update_status(name, 'Unpacked', workdir=workdir)
report('Deleting tar files')
os.system('rm ' + workdir + '/*.tar.gz')
os.system('rm ' + workdir + '/*.tar')
averaged = False
report('Checking structure')
g = glob.glob(workdir + '/*.ms')
msl = MSList(None, mss=g)
uobsids = set(msl.obsids)
for thisobs in uobsids:
# check one MS with each ID
for m, ch, o in zip(msl.mss, msl.channels, msl.obsids):
if o == thisobs:
channels = len(ch)
print 'MS', m, 'has', channels, 'channels'
if channels > 20:
update_status(name, 'Averaging', workdir=workdir)
print 'Averaging needed for', thisobs, '!'
averaged = True
average(wildcard=workdir + '/*' + thisobs + '*')
os.system('rm -r ' + workdir + '/*' + thisobs +
'*pre-cal.ms')
break
report('Making ms lists')
success = make_list(workdir=workdir)
if do_field:
list_db_update(success, workdir=workdir)
if not success:
die('make_list could not construct the MS list', database=False)
report('Creating custom config file from template')
make_custom_config(name, workdir, do_field, averaged)
# now run the job
do_run_job(name, basedir=basedir, qsubfile=None, do_field=do_field)
def test_average_five_values(self, input_values, expected_result):
"""Otestování výpočtu průměru."""
result = average(input_values)
assert result == expected_result, "Očekávaná hodnota {}, vráceno {}".format(
expected_result, result)
def test_average_basic_1(printer, values, expected):
"""Otestování výpočtu průměru."""
printer("About to compute average from {} with expected output {}".format(values, expected))
result = average(values)
printer("Computed average is {}".format(result))
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(expected, result)
def test_average_exception_not_raised():
"""Otestování výpočtu průměru."""
with pytest.raises(ZeroDivisionError) as excinfo:
result = average([1, 2])
import average print(average.average(2, 3)) print(average.average(10, 15))
def setUp(self):
self.average = average()
def moving_average(series, n): return average(series[-n:])
from argparse import ArgumentParser
from average import average
from rwcsv import csv_write, csv_read
if __name__ == "__main__":
"""
The entrypoint for the column averaging software suite.
"""
parser = ArgumentParser(description="Give it a input csv")
parser.add_argument("inputcsv")
parser.add_argument("outputcsv")
arguments = parser.parse_args()
data_columns = csv_read(arguments.inputcsv)
average_columns = average(data_columns)
write_csv = csv_write(arguments.outputcsv, average_columns)
def main():
x = average(1, 2, 3, 4, 5)
print(x)
def test_running_list_mag_negative(self): # 4
"""Test a list of negative values."""
argument = [-1, -5, -3, -4]
expected = -3.25
argument = avg.average(argument)
self.assertEqual(expected, argument, "The list contains only negative values.")
def test_does_not_accept_strings(self):
result = average.average(["ten", "two", 3, 4, 5])
self.assertEqual("numbers only", result)
def test_empty(self):
lst = []
ans = _("When the list is empty you should return None.")
self.assertEqual(None, average.average(lst), ans)
def maquinaVirtual():
global cuadActual, pilaContexto,contadorParam, pilaCuadActual, pilaReturn, contadorFuncEspeciales, pilaFuncionesEspeciales
while cuadActual < cuad.contQuadAux:
#print(cuadActual)
#print(pilaContexto)
#print(mem.tablaMemoriaEjecución)
if cuad.PQuad[cuadActual]['operator'] == 'GOTO':
cuadActual = cuad.PQuad[cuadActual]['result']
elif cuad.PQuad[cuadActual]['operator'] == 'PRINT':
direccionVar = cuad.PQuad[cuadActual]['result']
if type(direccionVar) == str:
direccionVar = mem.cambiaDireccion(direccionVar,pilaContexto[len(pilaContexto)-1])
print("IMPRIME CONSOLA:",mem.obtenerValordeMemoria(direccionVar,pilaContexto[len(pilaContexto)-1]))
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'READ':
direccionRead = cuad.PQuad[cuadActual]['result']
print(direccionRead)
valorRead = input("INGRESA EL VALOR DE LA VAR: ")
def get_type(input_data): #Identifica que tipo es lo que se ingreso'
try:
return type(literal_eval(input_data))
except (ValueError, SyntaxError):
# A string, so return str
return str
valorTipo = str(get_type(valorRead)) #Aqui guarda string
#<class 'int'>
#<class 'float'>
#<class 'bool'>
#<class 'string'>
#dependiendo lo ingresado
#En esta parte se comprueba que el tipo del valor ingresado concuerde
#con el tipo de la variable ya antes declarada, si es asi, el valor
#es convertido a el tipo correspondiente y lo almacena en memoria
if (valorTipo[8] == 'i'):
print('Lo que se ingresó es tipo int')
if (direccionRead >= 1000 and direccionRead < 3000) | (direccionRead >= 11000 and direccionRead < 13000):
print("Si concuerda con el tipo de la variable")
inputVal = int(valorRead)
else:
print("HORROR DE TIPOS")
sys.exit()
elif (valorTipo[8] == 'f'):
print('Lo que se ingresó es tipo float')
if (direccionRead >= 3000 and direccionRead < 5000) | (direccionRead >= 13000 and direccionRead < 15000):
print("Si concuerda con el tipo de la variable")
inputVal = float(valorRead)
else:
print("HORROR DE TIPOS")
sys.exit()
elif (valorTipo[8] == 'b'):
print('Lo que se ingresó es tipo bool')
if (direccionRead >= 5000 and direccionRead < 7000) | (direccionRead >= 15000 and direccionRead < 17000):
print("Si concuerda con el tipo de la variable")
inputVal = bool(valorRead)
else:
print("HORROR DE TIPOS")
sys.exit()
else:
print('Lo que se ingresó es tipo string')
if (direccionRead >= 7000 and direccionRead < 9000) | (direccionRead >= 17000 and direccionRead < 19000):
print("Si concuerda con el tipo de la variable")
inputVal = valorRead
else:
print("HORROR DE TIPOS")
sys.exit()
mem.almacenaMemoriaEjecucion(direccionRead ,inputVal,pilaContexto[len(pilaContexto)-1])
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == '=':
direccionVar = cuad.PQuad[cuadActual]['result']
#checa si es dir indirecta -- arrays
if type(direccionVar) == str:
direccionVar = mem.cambiaDireccion(direccionVar,pilaContexto[len(pilaContexto)-1])
left_operand = cuad.PQuad[cuadActual]['left_operand']
if type(left_operand) == str:
left_operand= mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
valor = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1])
mem.almacenaMemoriaEjecucion(direccionVar,valor,pilaContexto[len(pilaContexto)-1])
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == '+':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) + mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '+k':
resultado = cuad.PQuad[cuadActual]['right_operand'] + mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['left_operand'],pilaContexto[len(pilaContexto)-1])
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '+DirBASE':
resultado = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['left_operand'],pilaContexto[len(pilaContexto)-1]) + cuad.PQuad[cuadActual]['right_operand']
#print('+DirBASE',resultado)
direccion = '(' + str(cuad.PQuad[cuadActual]['result']) + ')'
#print(direccion)
mem.almacenaMemoriaEjecucion(direccion,resultado,pilaContexto[len(pilaContexto)-1])
#print(mem.tablaMemoriaEjecución)
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '-':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) - mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '*':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) * mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '/':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) / mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '>':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) > mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '<':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) < mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '==':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) == mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '!=':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) != mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '>=':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) >= mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == '<=':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) <= mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == 'AND':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) and mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == 'OR':
left_operand = cuad.PQuad[cuadActual]['left_operand']
right_operand = cuad.PQuad[cuadActual]['right_operand']
if type(left_operand) == str:
left_operand = mem.cambiaDireccion(left_operand,pilaContexto[len(pilaContexto)-1])
if type(right_operand) == str:
right_operand = mem.cambiaDireccion(right_operand,pilaContexto[len(pilaContexto)-1])
resultado = mem.obtenerValordeMemoria(left_operand,pilaContexto[len(pilaContexto)-1]) or mem.obtenerValordeMemoria(right_operand,pilaContexto[len(pilaContexto)-1])
#print('suma es igual', resultado)
mem.almacenaMemoriaEjecucion(cuad.PQuad[cuadActual]['result'],resultado,pilaContexto[len(pilaContexto)-1])
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == 'GOTOF':
evalua = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['left_operand'],pilaContexto[len(pilaContexto)-1])
if not evalua:
cuadActual = cuad.PQuad[cuadActual]['result']
else:
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'ERA':
#solicitar crear espeacio en memoria para la func
if cuad.PQuad[cuadActual]['left_operand'] != pilaContexto[len(pilaContexto)-1]:
pilaContexto.append(cuad.PQuad[cuadActual]['left_operand'])
mem.generaMemoriaEjecucion(pilaContexto[len(pilaContexto)-1])
else:
pilaContexto.append(cuad.PQuad[cuadActual]['left_operand'])
#print(mem.tablaMemoriaEjecución)
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == 'PARAM':
#obtener dir de memoria de param
tempVarParam = directorio.funcionLista[pilaContexto[len(pilaContexto)-1]]['paramDefinidos'][contadorParam]['name']
direccion = directorio.funcionLista[pilaContexto[len(pilaContexto)-1]]['variables'][tempVarParam]['dirMemoria']
#obtener los valores del contexto anterior en base a los cuads
valor = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['left_operand'],pilaContexto[len(pilaContexto)-2])
mem.almacenaMemoriaEjecucion(direccion,valor,pilaContexto[len(pilaContexto)-1])
contadorParam +=1
if cuad.PQuad[cuadActual+1]['operator'] == 'GOSUB':
contadorParam = 1
pilaCuadActual.append(cuadActual+1)
cuadActual = directorio.funcionLista[pilaContexto[len(pilaContexto)-1]]['cuadInicial']
else:
cuadActual+=1
elif cuad.PQuad[cuadActual]['operator'] == 'GOSUB':
if cuad.PQuad[cuadActual]['left_operand'] != pilaContexto[len(pilaContexto)-2]:
mem.tablaMemoriaEjecución[pilaContexto[len(pilaContexto)-1]].clear()
pilaContexto.pop()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'ENDPROC':
cuadActual = pilaCuadActual.pop()
elif cuad.PQuad[cuadActual]['operator'] == 'RETURN':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
direccion = directorio.funcionLista['MAIN']['variables'][pilaContexto[len(pilaContexto)-1]]['dirMemoria']
mem.almacenaMemoriaEjecucion(direccion,result,pilaContexto[len(pilaContexto)-2])
cuadActual +=1
elif cuad.PQuad[cuadActual]['operator'] == 'AVERAGE':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
pilaFuncionesEspeciales.append(result)
if len(pilaFuncionesEspeciales) == 4:
print('PROCESANDO DATOS.....')
avg.average(pilaFuncionesEspeciales[0],pilaFuncionesEspeciales[1],pilaFuncionesEspeciales[2],pilaFuncionesEspeciales[3])
pilaFuncionesEspeciales.clear()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'MEDIAN':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
pilaFuncionesEspeciales.append(result)
if len(pilaFuncionesEspeciales) == 4:
print('PROCESANDO DATOS.....')
median.median(pilaFuncionesEspeciales[0],pilaFuncionesEspeciales[1],pilaFuncionesEspeciales[2],pilaFuncionesEspeciales[3])
pilaFuncionesEspeciales.clear()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'MODE':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
pilaFuncionesEspeciales.append(result)
if len(pilaFuncionesEspeciales) == 2:
print('PROCESANDO DATOS.....')
mode.mode(pilaFuncionesEspeciales[0],pilaFuncionesEspeciales[1])
pilaFuncionesEspeciales.clear()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'PLOT':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
pilaFuncionesEspeciales.append(result)
if len(pilaFuncionesEspeciales) == 4:
print('PROCESANDO DATOS.....')
plot.plot(pilaFuncionesEspeciales[0],pilaFuncionesEspeciales[1],pilaFuncionesEspeciales[2],pilaFuncionesEspeciales[3])
pilaFuncionesEspeciales.clear()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'PIECHART':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
pilaFuncionesEspeciales.append(result)
if len(pilaFuncionesEspeciales) == 3:
print('PROCESANDO DATOS.....')
pie.pieChart(pilaFuncionesEspeciales[0],pilaFuncionesEspeciales[1],pilaFuncionesEspeciales[2])
pilaFuncionesEspeciales.clear()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'VARIANZA':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
pilaFuncionesEspeciales.append(result)
if len(pilaFuncionesEspeciales) == 4:
print('PROCESANDO DATOS.....')
varianza.varianza(pilaFuncionesEspeciales[0],pilaFuncionesEspeciales[1],pilaFuncionesEspeciales[2],pilaFuncionesEspeciales[3])
pilaFuncionesEspeciales.clear()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'DESVT':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
pilaFuncionesEspeciales.append(result)
if len(pilaFuncionesEspeciales) == 4:
print('PROCESANDO DATOS.....')
std.std(pilaFuncionesEspeciales[0],pilaFuncionesEspeciales[1],pilaFuncionesEspeciales[2],pilaFuncionesEspeciales[3])
pilaFuncionesEspeciales.clear()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'DISTN':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
pilaFuncionesEspeciales.append(result)
if len(pilaFuncionesEspeciales) == 2:
print('PROCESANDO DATOS.....')
dN.distN(pilaFuncionesEspeciales[0],pilaFuncionesEspeciales[1])
pilaFuncionesEspeciales.clear()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'BASICV':
result = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['result'],pilaContexto[len(pilaContexto)-1])
pilaFuncionesEspeciales.append(result)
if len(pilaFuncionesEspeciales) == 2:
print('PROCESANDO DATOS.....')
violin.violin(pilaFuncionesEspeciales[0],pilaFuncionesEspeciales[1])
pilaFuncionesEspeciales.clear()
cuadActual += 1
elif cuad.PQuad[cuadActual]['operator'] == 'VER':
valor = mem.obtenerValordeMemoria(cuad.PQuad[cuadActual]['left_operand'],pilaContexto[len(pilaContexto)-1])
if valor >= cuad.PQuad[cuadActual]['right_operand'] and valor <= cuad.PQuad[cuadActual]['result']:
pass
else:
print('HORROR: Numero fuera de los limites del arreglo')
return sys.exit()
cuadActual += 1
else:
cuadActual+=1
import average print(average.average(2, 2)) print(average.average(1, 10))
# Author: Sisinty Sasmita Patra # Runs all other techniques import cv2 import sys import time import average, xyz_lum, yuv_lum, lab_lum, lab_lum_en, color2gray in_file = sys.argv[1] + ".jpg" in1 = cv2.imread(in_file) # average start = time.clock() out1 = average.average(in1) end = time.clock() out_file = sys.argv[1] + "_out_avg.jpg" cv2.imwrite(out_file, out1) print "average : ", end - start, " seconds." # xyz start = time.clock() out1 = xyz_lum.xyz_luminance(in1) end = time.clock() out_file = sys.argv[1] + "_out_xyz.jpg" cv2.imwrite(out_file, out1) print "xyz_lum : ", end - start, " seconds." # yuv
def test_average_basic():
"""Otestování výpočtu průměru."""
result = average([1, 2])
assert result == 1.5
def average_all_sequence(self):
average(self)
def randorator(dict_val):
# The function gets the dictionary with input values.
from simple import rando
from average import average
from rsd import randorateGauss, relstdev, rsd_calc
# Modules to generate random numbers list are loaded.
# RSD adjusting and calculating modules are loaded.
from math import log, copysign
# Logarithm counting and sign copy functions are loaded.
from sys import version
# To support Python 2 & 3.
from i18n.locator import locale
# Localization.
if dict_val["log_algor"]:
from randomwrapper import shuffle
else:
from random import shuffle
# Here it is an import of a list shuffling function from the chosen module.
def punctu(txt):
try:
return(float(txt.replace(",", ".")))
except ValueError:
return(0)
#Функция принимает строковое значение и возвращает число с точкой. Для обработки введённых данных.
def set_float_data(in_data):
out_data = 0
if in_data != "":
out_data = punctu(in_data)
return(out_data)
#Функция принимает строковое значение и возвращает число с точкой или 0,
#если строка пустая. Для обработки введённых данных.
def set_int_data(in_data, fallback_d):
if in_data != "":
try:
out_data = int(round(abs(punctu(in_data)), 0))
except TypeError:
pass
else:
out_data = fallback_d
return(out_data)
#Функция принимает строковое значение и число, возвращает целое число
#или второе число, если строка пустая. Для обработки введённых данных.
def to_text(in_data, rounding):
if rounding >= 0:
in_data = round(in_data, rounding)
out_data = str(in_data)
out_data += "0" * (rounding - len(out_data) + out_data.find(".") + 1)
else:
out_data = str(in_data)
if rounding == 0:
out_data = out_data.replace(".0", "")
return(out_data)
#Число преобразуется в строку, если необходимо, округляется с добавлением нулей.
#У числа, округлённого до целой части, отбрасывается ".0".
def check_limits(limits_add, str_avera, n, mini, maxi, mean):
dict_check = {}
limits_n = len(limits_add)
dict_check["log_avera"] = False
if str_avera != "":
if n > limits_n:
mean = ((mean * n) - sum(limits_add)) / (n - limits_n)
# The mean value should be corrected.
dict_check["num_avera"] = mean
if maxi > mean > mini:
dict_check["log_avera"] = True
dict_check["str_error"] = u""
# New average value should be checked.
if not dict_check["log_avera"]:
dict_check["str_error"] = u"core_error_incompatibility"
dict_check["num_quant"] = max(0, (n - limits_n))
return(dict_check)
# Here it is a funcion to transform input value in according
# to correspond with interval limit(s) marked to be added.
def parse_sortm(str_sortm):
str_sortm = str_sortm.replace(","," ")
# Let comma be the valid separating character.
lst_sortm_in = str_sortm.split()
# The string is splitted by spaces into strings list.
lst_sortm_out = []
for i in lst_sortm_in:
if u"-" in i:
# A substring with a dash should be transformed.
n = i.split(u"-")
n0 = int(n[0])
n1 = int(n[1])
k = range(n0, n1, (int(copysign(1, (n1 - n0))))) + [n1]
# Also we should add right interval limit to the range.
lst_sortm_out += k
else:
lst_sortm_out.append(int(i))
return(lst_sortm_out)
# Here it is a function to parse input string with setted sorting mode.
def do_sortm(lst_numbz_in, str_sortm):
lst_sortm = parse_sortm(str_sortm)
lst_numbz_out = []
lst_numbz_in.sort()
for i in lst_sortm:
lst_numbz_out.append(lst_numbz_in[i - 1])
return(lst_numbz_out)
# Here it is a function to apply setted sorting mode.
def wrapError(ErrorID, Language, ErrorzList):
'''Prints error text and transfers it into UI.'''
ErrorText = locale(ErrorID, Language)
print(ErrorText)
if ErrorID.startswith(u"core_error"):
# Let's not show information messages at UI.
ErrorzList.append(ErrorText)
return(ErrorzList)
matrix = []
errorz = []
dict_txt = {
"str_numbz": u"",
"str_infoz": u""}
mini = set_float_data(dict_val["str_minim"])
maxi = set_float_data(dict_val["str_maxim"])
if (dict_val["str_avera"] != ""):
mean = punctu(dict_val["str_avera"])
n = set_int_data(dict_val["str_quant"], 1)
rounding = set_int_data(dict_val["str_round"], -1)
limits_add = []
if dict_val["log_min_v"]:
limits_add.append(mini)
if dict_val["log_max_v"]:
limits_add.append(maxi)
# Here it is a list with interval limit(s) marked to be added.
if dict_val["log_horiz"]:
NumbersSeparator = "\t"
# Horizontal numbers output into one row.
else:
NumbersSeparator = "\n"
# Vertical numbers output into one column.
if mini > maxi:
maxi, mini = mini, maxi
wrapError(u"core_error_min>max", dict_val["str_langu"], errorz)
#Если при вводе были перепутаны границы, то они меняются местами.
#Запись соответствующего сообщения об ошибке.
if dict_val["str_avera"] != "":
if dict_val["str_minim"] == "":
if mean > 0:
mini = 0
else:
mini = 10 * mean
if (mean == 0) and (dict_val["str_maxim"] != ""):
mini = -1 * maxi
if dict_val["str_maxim"] == "":
if mean > 0:
maxi = 10 * mean
else:
maxi = 0
if (mean == 0) and (dict_val["str_minim"] != ""):
maxi = -1 * mini
# If a limit value isn't set but an average value is set
# the limit will be calculated according to the average.
if (maxi > mean > mini):
average_used = True
else:
average_used = False
wrapError(u"core_error_incompatible_average", dict_val["str_langu"], errorz)
else:
average_used = False
wrapError(u"core_info_no_average", dict_val["str_langu"], errorz)
# The existence and the possibility of use of average value is checked.
#Запись соответствующего сообщения об ошибке.
if limits_add != []:
if average_used:
dict_check = check_limits(limits_add, dict_val["str_avera"], n, mini, maxi, mean)
average_used = dict_check["log_avera"]
if average_used:
mean = dict_check["num_avera"]
if dict_check["str_error"] != u"":
wrapError(dict_check["str_error"], dict_val["str_langu"], errorz)
else:
dict_check = check_limits(limits_add, "", n, mini, maxi, None)
n = dict_check["num_quant"]
m = n - 1
if version < '3':
fromzeroton = xrange(n)
fromzerotom = xrange(m)
else:
fromzeroton = range(n)
fromzerotom = range(m)
#Создаются пустые списки и текст. Обрабатываются числовые параметры.
#Вычисляется удобное число m. Создаются удобные списки.
rsd_used = False
rsd_used2 = False
if dict_val["str_rsd_p"] != "":
if (not dict_val["log_max_v"]) and (not dict_val["log_min_v"]):
# RSD adjustment with maximum or minimum included to the output isn't implemented.
if n > 1:
if (mini * maxi >= 0):
rsd = punctu(dict_val["str_rsd_p"])
if not average_used:
mean = (mini + maxi) / 2
if mean != 0:
if rsd > 0:
rsd_used = True
if dict_val["log_rsd_w"]:
matrix = randorateGauss(fromzeroton, mean, (mean * rsd / 100))
print(u"RSD value was selected and randorated.")
rsd_used2 = True
if dict_val["log_algor"]:
errorz.append(u"No true random if precise RSD value!")
# rsd_used2 indicates if matrix has been already randorated.
# rsd_used indicates if rsd algorithms will be used at all.
else:
errorz.append(u"RSD должно быть больше 0!")
print(u"RSD value was selected but couldn't be randorated.")
else:
errorz.append(u"RSD не может быть рассчитано для интервала, включающего 0!")
print(u"RSD value was selected but couldn't be randorated.")
else:
errorz.append(u"RSD не может быть рассчитано менее чем для двух чисел!")
print(u"RSD value was selected but couldn't be randorated.")
else:
errorz.append(u"Оптимизация по RSD отключена при добавлении границы интервала!")
print(u"RSD value was selected but couldn't be randorated.")
# If fixed RSD value is set and can be used Gauß distribution will be randorated.
if (not rsd_used2):
if average_used:
matrix = average(mini, maxi, n, mean, m, fromzerotom, dict_val["log_algor"])
print(u"Average value was selected and randorated.")
else:
matrix = rando(mini, maxi, fromzeroton, dict_val["log_algor"])
if rsd_used:
if not average_used:
mean = sum(matrix) / n
dict_torsd = {
"lst_numbz": matrix,
"str_quant": n,
"str_avera": mean,
"str_rsd_p": rsd,
"lst_index": fromzeroton,
"log_rsd_w": dict_val["log_rsd_w"]}
dict_rsd = relstdev(dict_torsd)
rsd_used = True
# RSD value is adjusted.
if dict_val["log_min_v"]:
matrix.append(mini)
if dict_val["log_max_v"]:
matrix.append(maxi)
# Selected numbers are included to the output.
if not (mini == maxi == 0):
mini = abs(mini)
maxi = abs(maxi)
if mini > maxi:
maxi, mini = mini, maxi
if mini == 0:
mini = maxi / 10
elif maxi == 0:
maxi = mini * 10
# Logarithm of nonpositive numbers couldn't be calculated!
log_mini = log(mini, 10)
if (log_mini > 11) or (log(maxi, 10) < -4):
if rounding != -1:
errorz.append(u"Округление больших и маленьких чисел не поддерживается!")
rounding = -1
# Rounding of small and big numbers doesn't work.
else:
round_max = (-1 * log_mini) + 11
if rounding > round_max:
rounding = int(round_max)
errorz.append(u"Не более " + str(rounding) + u" цифер после запятой!")
# If rounding is set more than the maximum value
# that could be applied the rounding is truncated.
else:
errorz.append(u"Кого бы поделить на ноль?")
rounding = 0
# Here it is an easter egg ^,,^
if dict_val["log_rsd_a"]:
rsd_out = [False, None]
if rsd_used:
rsd_out = [True, dict_rsd["num_rsd_q"]]
# Use calculated RSD value when it exists.
else:
if (n > 1) and (mini * maxi >= 0):
if not average_used:
mean = sum(matrix) / n
if mean != 0:
rsd_out = [True, rsd_calc(fromzeroton, matrix, mean, n, True)]
# Or calculate it if it is possible.
else:
errorz.append(u"Невозможно рассчитать RSD!")
print(u"RSD couldn't be calculated.")
if rsd_out[0]:
dict_txt["str_infoz"] += str(sum(matrix) / n) + u"; RSD, % = " + str(rsd_out[1])
# If RSD is requested to show and could be get it will be outputed.
# NOTE I don't really understand why this code is required but it is:
if ((errorz != []) and (dict_val["log_verbo"])):
dict_txt["str_infoz"] = "\n" + dict_txt["str_infoz"]
else:
dict_txt["str_infoz"] = dict_txt["str_infoz"] + "\n"
# End of NOTE
if dict_val["log_verbo"] and (errorz != []):
TempList = []
if version < '3':
ErrorzIndex = xrange(len(errorz))
else:
ErrorzIndex = range(len(errorz))
for i in ErrorzIndex:
TempList.append(errorz[i])
TempList.append("\n")
dict_txt["str_infoz"] = dict_txt["str_infoz"].join(TempList)
#Если задано, и ошибки есть, они переносятся в текст.
if matrix != []:
n = len(matrix)
m = n - 1
if version < '3':
fromzerotom = xrange(m)
else:
fromzerotom = range(m)
# Proper values are restored.
if dict_val["str_sortm"] != u"":
if dict_val["str_sortm"] == u"1-":
matrix.sort()
elif dict_val["str_sortm"] == u"-1":
matrix.sort()
matrix.reverse()
else:
try:
matrix = do_sortm(matrix, dict_val["str_sortm"])
except (IndexError, ValueError, UnicodeEncodeError):
dict_txt["str_infoz"] += u"Некорректный режим сортировки!" + "\n"
else:
if n > 2:
shuffle(matrix)
TempList = []
for i in fromzerotom:
TempList.append(to_text(matrix[i], rounding))
TempList.append(NumbersSeparator)
if m >= 0:
TempList.append(to_text(matrix[m], rounding))
dict_txt["str_numbz"] = dict_txt["str_numbz"].join(TempList)
#Cписок c количеством элементов больше 3 перемешивается и преобразуется в текст.
#Каждое число с красной строки. Округление при необходимости.
if not dict_val["log_punct"]:
dict_txt["str_numbz"] = dict_txt["str_numbz"].replace(".", ",")
#Если требуется, то точки заменяются запятыми.
return(dict_txt)
def test_average_empty_list_1():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(ZeroDivisionError) as excinfo:
result = average([])
data from BMP180 publish everything via MQTT.
"""
args = sys.argv
delay = 10.0
if len(args) > 1:
delay = float(args[1])
result = dht.read()
if result.is_valid():
humidity.append(result.humidity)
i += 1
if time_i == 30:
data = bmp.read()
data["humidity"] = average(humidity)
data["light"] = light.read()
data["moisture"] = moisture.read()
i = 0
time_i = 0
humidity = []
ts = int(time.time())
log.debug("Sending MQTT messages")
publish.single(MQTT_TEMP,"{0};{1}".format(ts, data["temperature"]), hostname=HOST)
publish.single(MQTT_HUM,"{0};{1}".format(ts, data["humidity"]), hostname=HOST)
publish.single(MQTT_PRES,"{0};{1}".format(ts, data["pressure"]), hostname=HOST)
publish.single(MQTT_LIGHT,"{0};{1}".format(ts, data["light"]), hostname=HOST)
publish.single(MQTT_MOISTURE,"{0};{1}".format(ts, data["moisture"]), hostname=HOST)
time_i += 1
csvfile_write.close()
#new item
else:
print('\t' + vg_csv_file(vagetable) + ' do not exist')
print('\tcreat ' + vg_csv_file(vagetable))
csvfile = open(vg_csv_file(vagetable), 'w', newline='')
fieldnames = ['year', 'month', 'day', 'weight', 'price']
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
#parse from default_start_date
date = default_start_date
while (date != end_date):
data = get_oneday(vagetable, date)
print('\t', data)
#one day
writer.writerow({
'year': data['year'],
'month': data['month'],
'day': data['day'],
'weight': data['weight'],
'price': data['price']
})
date += oneday
csvfile.close()
average()
typhoon()
merge()
transToJson()
#!/usr/bin/env python
from argparse import ArgumentParser
import array
import average
size = 10
arg_parser = ArgumentParser(description='test Cython errors')
arg_parser.add_argument('--m', type=int, default=0, help='lower bound')
arg_parser.add_argument('--n', type=int, default=size, help='upper bound')
options = arg_parser.parse_args()
data = array.array('d', list(range(size)))
print('with except:')
try:
print(average.average(data, options.m, options.n))
except Exception as e:
print('caught exception {0}: {1}'.format(str(e.__class__), str(e)))
print('without except:')
try:
print(average.average_no_except(data, options.m, options.n))
print('no exception caught')
except Exception as e:
print('caught exception {0}: {1}'.format(e.__class__, str(e)))
def test_average():
items = [100, 50]
assert average.average(items) == 75
def test_average_empty_list():
"""Otestování výpočtu průměru."""
result = average([])
expected = 0.0
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result)
def test_running_list_mag_items(self): # 3
"""Test a two-item list."""
argument = [5, 2]
expected = 3.5
argument = avg.average(argument)
self.assertEqual(expected, argument, "The list contains two items.")
def test_average_basic():
"""Otestování výpočtu průměru."""
result = average([1, 2])
expected = 1.5
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result)
def test_running_list_mag_zeros(self): # 5
"""Test a list of zeros."""
argument = [0, 0, 0, 0]
expected = 0
argument = avg.average(argument)
self.assertEqual(expected, argument, "The list contains only zeros.")
def test_calculates_average_of_numbers_in_list(self):
result = average.average([10, 2, 3, 4, 5])
self.assertEqual(4.8, result)
