def __init__(self,
path,
current_yr=None,
force_new_download=False,
forms=['PF', 'EZ', 'Full'],
backfill=2,
tolerance=1000,
do_validation=True,
clear_old=True,
partial_validation=True,
get_from_sql=True,
output_full=True):
forms = [f.upper() for f in forms]
self.forms = ['Full' if f == 'FULL' else f for f in forms]
self.path = path
self.force_new_download = force_new_download
self.logger, self.start = self.start_logging(path, current_yr)
self.data = data.Data(self, clear_old, get_from_sql, current_yr,
backfill)
self.process = process.Process(self)
self.validate = validate.Validate(self, tolerance, do_validation,
partial_validation)
self.write = write.Write(self, output_full)
def __init__(self, filename, _type, key=None):
self.filename = filename
self.type = _type
self.key = key
self.read = read.Read()
self.write = write.Write()
self.add = add.Add()
def __init__(self):
self.power = True
self.sudoku = np.zeros((9, 9), int)
self.Write = write.Write()
self.Server = server.Server(self)
self.MotorControl = stp.MotorControl()
self.MotorControl.start()
os.chdir("/home/pi/Desktop/Sudoku-Plotter/script/lcd")
lcd3.write("Sudoku Plotter Welcome!")
async def main():
writer = write.Write(filename=filename)
reader = read.Read(filename=filename)
local_data = lambda: data.Data.GenerateData()
# await writer.WriteData(local_data)
H = await asyncio.gather(
writer.BatchWrite(5),
reader.BatchRead(5),
)
def main():
""" runs the HELIOS RT computation """
# instantiate the classes
reader = read.Read()
keeper = quant.Store()
computer = comp.Compute()
writer = write.Write()
plotter = rt_plot.Plot()
# read input files and do preliminary calculations
reader.read_input(keeper)
reader.read_opac(keeper)
keeper.dimensions()
reader.read_star(keeper)
hsfunc.gaussian_weights(keeper)
hsfunc.spec_heat_cap(keeper)
hsfunc.planet_param(keeper)
hsfunc.initial_temp(keeper, reader)
# get ready for GPU computations
keeper.convert_input_list_to_array()
keeper.create_zero_arrays()
keeper.copy_host_to_device()
keeper.allocate_on_device()
# conduct the GPU core computations
computer.construct_planck_table(keeper)
computer.construct_grid(keeper)
computer.construct_capital_table(keeper)
computer.init_spectral_flux(keeper)
computer.iteration_loop(keeper, writer, plotter)
computer.calculate_mean_opacities(keeper)
computer.calculate_transmission(keeper)
# copy everything back to host and write to files
keeper.copy_device_to_host()
writer.write_info(keeper, reader)
writer.write_tp(keeper)
writer.write_column_mass(keeper)
writer.write_integrated_flux(keeper)
writer.write_downward_spectral_flux(keeper)
writer.write_upward_spectral_flux(keeper)
writer.write_planck_interface(keeper)
writer.write_planck_center(keeper)
writer.write_opacities(keeper)
writer.write_transmission(keeper)
writer.write_mean_extinction(keeper)
# prints the success message - yay!
hsfunc.success_message()
def __init__(self):
self.beta_version = True
self.error = []
self.taille = (3, 3)
self.mode = "Directe"
self.nb_cases = self.taille[0] * self.taille[1]
self.sudoku = np.zeros((self.nb_cases, self.nb_cases), int)
self.methode_resolution = "Globale"
self.liste_position = []
self.W = w.Write()
self.Client = client.Client(self)
self.Resolution = rs.Resolution(self)
self.Display = dp.Display(self)
self.Resolution.start()
self.Display.mainloop()
def home():
if request.method == 'POST':
data = request.get_json() # Get Data from JS
aux = data['cadena'].split('\n')
lista = []
for x in aux:
for j in x.split(';'):
if len(j) > 0:
lista.append(j)
errores = []
var = []
count = 0
lista, errores = While.While(lista).Search_While(errores)
for l in lista:
if '<' in l or '>' in l or '==' in l:
if Logic.Logic().SintaxLogic(l):
# Check if they are the same typ
errores = Logic.Logic().CheckSintax(l, var, errores)
else:
errores.append('Error de la sintaxis en ' + l)
if '=' in l and Equals.Equals(l).CheckString() == True:
temp = l.split('=')
if len(temp) < 2 or len(temp) > 2:
errores.append('Error de sintaxis' + l)
else:
# we hake to check if the var has already been in the list
result, T, index = Search.Search().Search_Name(
var, temp[0])
if result == True:
# Check if the value is a number or a var
if Is_there_letter(temp[1]) and ('"' in l
or "'" in l) == False:
if '+' in temp[1] or '-' in temp[1] or '*' in temp[
1] or '/' in temp[1]:
errores, var = Operation.Operation(l).Convert(
var, errores)
else:
errores, var = CheckAssig.Check(
).Check_Var_Var(l, T, index, errores, var,
temp)
else:
if '+' in temp[1] or '-' in temp[1] or '*' in temp[
1] or '/' in temp[1]:
errores, var = Operation.Operation(l).Convert(
var, errores)
else:
errores, var = CheckAssig.Check(
).Check_Var_Value(l, AssignTree, errores, var,
index, T, temp)
else:
errores.append('Error variable no declarada ' + l)
if ('Write(' in l) == False and (
'while' in l
) == False and l != '(' and l != ')' and l != '{' and l != '}' and (
'=' in l) == False and ('<' in l or '>' in l) == False:
errores, var = Type.Type().types(Trees, l, errores, var)
if 'Write(' in l:
errores = write.Write(l, var=var,
errores=errores).CheckSintax()
pass
count = count + 1
#aqui tengo q convertir el diccionario a json
diccionario_vars = {}
for let in var:
diccionario_vars[let.name] = {
'type': let.Type,
'name': let.name,
'value': let.value
}
return jsonify({'mensajes': errores, 'variables': diccionario_vars})
return render_template('index.html')