def __get_base_scenario(self, scenario): scenario_id = -1 try: db = config.get_db() try: query = """ select scenario_id from scenario ,( select location from scenario inner join footprint using (scenario_id) where footprint.name='study_area' and scenario_id={scenario} ) pb where is_base=1 and st_equals(pb.location, location) """.format(scenario=scenario) db.execute(query) scenarios = db.fetchall() scenario_id = scenarios[0][0] db.close() return scenario_id except Exception as e: LogEvents("An error happend while getting the base scenario", str(e), -1, sys.argv[1]) db.close() except Exception as e: LogEvents("Unknown error", str(e), -1, sys.argv[1]) return scenario_id
def __ModulejobDensity(self, scenario_id, offset=0, limit=0): try: error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: with transaction.atomic(): query = """select urbper_indicator_job_density({scenario},{offset},{limit})""".format( scenario=scenario_id, offset=offset, limit=limit) LogEvents("job density", "job density module started: " + query, scenario_id, self.__user) db.execute(query) except Exception as e: error = True count += 1 LogEvents( "job density ", "job density module failed " + str(count) + ": " + str(e), scenario_id, self.__user, True) db.close() else: error = False LogEvents("job density ", "job density module finished", scenario_id, self.__user) db.close() except Exception as e: LogEvents("Running scenarios", "Unknown error " + str(e), scenario_id, self.__user, True)
def run(self): try: error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_potable_water_network({scenario}) """.format(scenario=self.__scenario) LogEvents("potable water network", "potable water network module started: " + query, self.__scenario, self.__user) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "potable water network", "potable water network module failed " + str(count) + ": " + str(e), self.__scenario, self.__user) else: error = False db.close() LogEvents("potable water network", "potable water network module finished", self.__scenario, self.__user) except Exception as e: LogEvents("potable water network", "unknown error " + str(e), self.__scenario, self.__user)
def __getClassess(self, fclass): try: query = """select distinct classification.name from classification where classification.category='footprint' and classification.fclass='{fclass}' """.format(fclass=fclass) results = classification.objects.filter( category='footprint', fclass=fclass).distinct().values_list('name', flat=True) LogEvents("classes", "classes finished: " + query, self.__scenario, self.__user) results_set = [row for row in results] results = results_set except Exception as e: error = True time.sleep(randint(1, 3)) LogEvents("classes", "classes failed: " + str(e), self.__scenario, self.__user) return [] else: error = False LogEvents("classes", "classes finished", self.__scenario, self.__user) return results
def run(self): try: self.__Indicator = Indicator(self.__user) road_classes=self.__getClassess("road_infrastructure","roads") road_classes_array="'{"+",".join(road_classes)+"}'" risk_classes=self.__getClassess("risk","risk") risk_classes_array="'{"+",".join(risk_classes)+"}'" error = True count = 0 while error and count < 3: print("Entrando\n") self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_road_infrastructure_in_risk({scenario},'road_risk'::varchar(10),{road_class},{risk_classes}) """.format( scenario=self.__scenario, road_class=road_classes_array, risk_classes=risk_classes_array ) LogEvents( "road infrastructure in risk", "road infrastructure in risk module started: " + query, self.__scenario, self.__user ) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "road infrastructure in risk", "road infrastructure in risk module failed " + str(count) + ": " + str(e), self.__scenario, self.__user ) else: error = False db.close() LogEvents( "road infrastructure in risk", "road infrastructure in risk module finished", self.__scenario, self.__user ) except Exception as e: LogEvents( "road infrastructure in risk", "unknown error " + str(e), self.__scenario, self.__user )
def run(self): try: self.__Indicator = Indicator(self.__user) inadequate_classes=self.__getClassess("inadequate_hu") inadequate_array="'{"+",".join(inadequate_classes)+"}'" error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_population_inadequate_housing({scenario},{inadequate}) """.format( scenario=self.__scenario, inadequate=inadequate_array ) LogEvents( "urbper_indicator population in inadequate housing", "population in inadequate housing started: " + query, self.__scenario, self.__user ) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "population in inadequate housing", "population in inadequate housing module failed " + str(count) + ": " + str(e), self.__scenario, self.__user ) else: error = False db.close() LogEvents( "population in inadequate housing", "population in inadequate housing module finished", self.__scenario, self.__user ) except Exception as e: LogEvents( "population in inadequate housing", "unknown error " + str(e), self.__scenario, self.__user )
def run(self): try: self.__Indicator = Indicator(self.__user) greenland_classes=green_classes=self.__getClassess("green_land") greenland_array="'{"+",".join(greenland_classes)+"}'" error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_green_land_consumption({scenario},'greenland_consumption',{greenland}) """.format( scenario=self.__scenario, greenland=greenland_array, ) LogEvents( "green land consumption", "green land consumption module started: " + query, self.__scenario, self.__user ) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "green land consumption", "green land consumption module failed " + str(count) + ": " + str(e), self.__scenario, self.__user ) else: error = False db.close() LogEvents( "green land consumption", "green land consumption module finished", self.__scenario, self.__user ) except Exception as e: LogEvents( "green land consumption", "unknown error " + str(e), self.__scenario, self.__user )
def __evaluateAmenityBuffers(self): import psycopg2 import psycopg2.extras try: error = True count = 0 while error and count < 3: try: query = """ select urbper_buffer_amenities({scenario}) """.format(scenario=self.__scenario) LogEvents( "amenity buffers", "amenity buffer module started: " + query, self.__scenario, self.__user ) conn = psycopg2.connect(self.__Indicator.get_uri()) cursor = conn.cursor( cursor_factory=psycopg2.extras.DictCursor) old_isolation_level = conn.isolation_level conn.set_isolation_level(0) cursor.execute(query) conn.commit() conn.set_isolation_level(old_isolation_level) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) LogEvents( "amenity buffers", "amenity buffers module failed " + str(count) + ": " + str(e), self.__scenario, self.__user ) else: error = False LogEvents( "amenity buffers", "amenity buffers module finished", self.__scenario, self.__user ) except Exception as e: LogEvents( "amenity buffers", "unknown error " + str(e), self.__scenario, self.__user )
def run(self): try: error = True count = 0 dwells_classes= self.__getAmenityClassess() dwells_array="'{"+",".join(dwells_classes)+"}'" while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_potable_water_wells({scenario},{fclass_array}) """.format( scenario=self.__scenario,fclass_array=dwells_array ) LogEvents( "potable water wells", "potable water wells module started: " + query, self.__scenario, self.__user ) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "potable water wells", "potable water wells module failed " + str(count) + ": " + str(e), self.__scenario, self.__user ) else: error = False db.close() LogEvents( "potable water wells", "potable water wells module finished", self.__scenario, self.__user ) except Exception as e: LogEvents( "potable water wells", "unknown error " + str(e), self.__scenario, self.__user )
def __getAmenitiesClassess(self): try: error = True count = 0 while error and count < 3: try: with connection.cursor() as cursor: query=""" select distinct amenities.fclass from amenities inner join classification on classification.name=amenities.fclass where classification.category='amenities' and classification.fclass='educational_infrastructure' and amenities.scenario_id={}""".format(self.__scenario) LogEvents( "amenities fclasses", "amenities fclasses started: " + query, self.__scenario, self.__user ) cursor.execute(query) results_set=[list(row)[0] for row in cursor.fetchall()] results=results_set except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) LogEvents( "amenities fclasses", "amenities fclasses failed " + str(count) + ": " + str(e), self.__scenario, self.__user ) else: error = False LogEvents( "amenities fclasses", "amenities fclasses finished", self.__scenario, self.__user ) return results except Exception as e: LogEvents( "amenities fclasses", "unknown error " + str(e), self.__scenario, self.__user )
def __getAmenityClassess(self): try: error = True count = 0 while error and count < 3: try: query="""select distinct classification.name from classification where classification.category='amenities' and classification.fclass='dwells' """ results = classification.objects.filter(category='amenities',fclass='dwells').distinct().values_list('name',flat=True) LogEvents( "dwells", "dwells classes finished: " + query, self.__scenario, self.__user ) # cursor.execute(query) results_set=[row for row in results] results=results_set except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) LogEvents( "dwells", "dwells classes failed " + str(count) + ": " + str(e), self.__scenario, self.__user ) else: error = False LogEvents( "dwells", "dwells classes finished", self.__scenario, self.__user ) return results except Exception as e: LogEvents( "dwells", "unknown error " + str(e), self.__scenario, self.__user )
def run(self): try: error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: amenity_classes = [] amenity_classes.append("elementary_school") amenity_classes_array="'{"+",".join(amenity_classes)+"}'" query = """ select urbper_indicator_elementary_school_capacity({scenario},'elementary_capacity'::varchar(30),{fclass_array}) """.format(scenario=self.__scenario, fclass_array=amenity_classes_array) LogEvents( "elementary school capacity", "elementary school capacity module started: " + query, self.__scenario, self.__user ) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "elementary school capacity", "elementary school capacity module failed " + str(count) + ": " + str(e) , self.__scenario, self.__user ) else: error = False db.close() LogEvents( "elementary school capacity", "elementary school capacity module finished", self.__scenario, self.__user ) except Exception as e: LogEvents( "elementary school capacity", "unknown error " + str(e), self.__scenario, self.__user )
def run(self): try: # get agricultural land agricultural_sus = self.__getClassess("agricultural_sus") # get sustainable agricultural land agricultural_sus_array = "'{" + ",".join(agricultural_sus) + "}'" agricultural = self.__getClassess("agricultural") agricultural_array = "'{" + ",".join(agricultural) + "}'" error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_sustainable_agricultural_land({scenario},{agricultural_sus_array},{agricultural_array}) """.format( scenario=self.__scenario, agricultural_sus_array=agricultural_sus_array, agricultural_array=agricultural_array) LogEvents( "sustainable agricultural land", "sustainable agricultural land started: " + query, self.__scenario, self.__user) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "sustainable agricultural land", "sustainable agricultural land module failed " + str(count) + ": " + str(e), self.__scenario, self.__user) else: error = False db.close() LogEvents("sustainable agricultural land", "sustainable agricultural land module finished", self.__scenario, self.__user) except Exception as e: LogEvents("sustainable agricultural land", "unknown error " + str(e), self.__scenario, self.__user)
def run(self): try: self.__Indicator = Indicator(self.__user) heritage_area_classes_set = assumptions.objects.filter( category='heritage').values("name") heritage_area_classes = [] for heritage_area in list(heritage_area_classes_set): heritage_area_classes.append(heritage_area["name"]) heritage_area_array = "'{" + ",".join(heritage_area_classes) + "}'" error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_solid_waste_management_coverage({scenario},'solidw_coverage') """.format( scenario=self.__scenario, heritage_area=heritage_area_array, ) LogEvents( "solid waste management coverage", "solid waste management coverage module started: " + query, self.__scenario, self.__user) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "solid waste management coverage", "solid waste management coverage module failed " + str(count) + ": " + str(e), self.__scenario, self.__user) else: error = False db.close() LogEvents( "solid waste management coverage", "solid waste management coverage module finished", self.__scenario, self.__user) except Exception as e: LogEvents("solid waste management coverage", "unknown error " + str(e), self.__scenario, self.__user)
def run(self): try: error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_elementary_school_ratio({scenario},'elemax_perc'::varchar(30)) """.format(scenario=self.__scenario) LogEvents( "elementary school ratio", "elementary school ratio module started: " + query, self.__scenario, self.__user ) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "elementary school ratio", "elementary school ratio module failed " + str(count) + ": " + str(e) , self.__scenario, self.__user ) else: error = False db.close() LogEvents( "elementary school ratio", "elementary school ratio module finished", self.__scenario, self.__user ) except Exception as e: LogEvents( "elementary school ratio", "unknown error " + str(e), self.__scenario, self.__user )
def __init__(self, user, scenarios, indicators): LogEvents("Start scenario", "Starting all scenarios proccesing", -1, 1) self.user = user self.indicator = Indicator(self.user) if scenarios != "": self.scenarios = [ int(scenario.strip()) for scenario in scenarios.split('_') ] self.base_scenario = self.__get_base_scenario(self.scenarios[0]) if self.base_scenario in self.scenarios: if len(self.scenarios) > 1: self.scenarios.append( self.scenarios.pop( self.scenarios.index( self.scenarios.index(self.base_scenario)))) if indicators != "": self.indicators = indicators.split('_') indicator_param = [] for indicator_set in self.indicators: indicator_param.append(indicator_set.strip()) order = Modules.objects.filter( module__in=indicator_param).values("module").order_by('order') self.indicators = [] for module_in in order: self.indicators.append(module_in["module"]) self.copiados = dict(buffers=True, policies=True, amenities=[], transit=[], cycle=[], footprint=[], roads=[])
def run(self): try: self.__Indicator = Indicator(self.__user) self.__db = self.__Indicator.get_up_calculator_connection() vacuum(self.__Indicator.get_uri(), "mmu") self.__db.close() amenity_classes_set = self.__getAmentityClassess() error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: for amenity in amenity_classes_set: amenity_classes = [] amenity_classes.append(amenity) amenity_classes_array = "'{" + ",".join( amenity_classes) + "}'" query = """ select urbper_indicator_pop_amenity_prox({scenario},'pop_prox_{fclass}'::varchar(30),'{fclass}_proximity'::varchar(30),{fclass_array}) """.format(scenario=self.__scenario, fclass=amenity, fclass_array=amenity_classes_array) LogEvents( amenity + " proximity", amenity + " proximity module started: " + query, self.__scenario, self.__user) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "amenity proximity", "amenity proximity module failed " + str(count) + ": " + str(e), self.__scenario, self.__user) else: error = False db.close() LogEvents("amenity proximity", "amenity proximity module finished", self.__scenario, self.__user) except Exception as e: LogEvents("amenity proximity", "unknown error " + str(e), self.__scenario, self.__user)
def __mmu_limit_offset(self): try: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: # get the max an min of pk self.__limits["inferior"] = mmu.objects.filter( scenario_id=self.__scenario).aggregate(Min('mmu_id'))["mmu_id__min"] self.__limits["superior"] = mmu.objects.filter( scenario_id=self.__scenario).aggregate(Max('mmu_id'))["mmu_id__max"] except Exception as e: LogEvents("squares max min", "unknown error " + str(e), self.__scenario, self.__user, True) db.close() except Exception as e: LogEvents("squares max min", "unknown error " + str(e), self.__scenario, self.__user, True)
def run(self): try: self.__Indicator = Indicator(self.__user) amenity_classes = self.__getAmenitiesClassess() amenity_classes_array = "'{" + ",".join(amenity_classes) + "}'" risk_classes = self.__getRiskClassess() risk_classes_array = "'{" + ",".join(risk_classes) + "}'" error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_health_infrastructure_in_risk({scenario},'health_risk',{amenity_class},{risk_classes}) """.format(scenario=self.__scenario, amenity_class=amenity_classes_array, risk_classes=risk_classes_array) LogEvents( "health infrastructure in risk", "health infrastructure in risk module started: " + query, self.__scenario, self.__user) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "health infrastructure in risk", "health infrastructure in risk module failed " + str(count) + ": " + str(e), self.__scenario, self.__user) else: error = False db.close() LogEvents("health infrastructure in risk", "health infrastructure in risk module finished", self.__scenario, self.__user) except Exception as e: LogEvents("health infrastructure in risk", "unknown error " + str(e), self.__scenario, self.__user)
def __jobs_limit_offset(self): try: try: # get the max an min of pk self.__limits["inferior"] = jobs.objects.filter( scenario_id=self.__scenario).aggregate(Min('jobs_id'))["jobs_id__min"] self.__limits["superior"] = jobs.objects.filter( scenario_id=self.__scenario).aggregate(Max('jobs_id'))["jobs_id__max"] except Exception as e: LogEvents("jobs max min", "unknown error " + str(e), self.__scenario, self.__user, True) except Exception as e: LogEvents("jobs max min", "unknown error " + str(e), self.__scenario, self.__user, True)
def __ModuleJobsDensity(self, scenario_id, offset=0, limit=0): import psycopg2 import psycopg2.extras try: error = True count = 0 while error and count < 3: try: query = """select urbper_buffer_job_and_job_density({scenario},{offset},{limit})""".format( scenario=scenario_id, offset=offset, limit=limit) LogEvents( "job buffers and density", "job buffers and density module started: " + query, scenario_id, self.__user) conn = psycopg2.connect(self.__Indicator.get_uri()) cursor = conn.cursor( cursor_factory=psycopg2.extras.DictCursor) old_isolation_level = conn.isolation_level conn.set_isolation_level(0) cursor.execute(query) conn.commit() conn.set_isolation_level(old_isolation_level) except Exception as e: error = True count += 1 LogEvents( "job buffers and density ", "job buffers and density module failed " + str(count) + ": " + str(e), scenario_id, self.__user, True) else: error = False # db.commit() LogEvents("job buffers and density ", "job buffers and density module finished", scenario_id, self.__user) except Exception as e: LogEvents("Running scenarios", "Unknown error " + str(e), scenario_id, self.__user, True)
def __ModuleAreaDensity(self, scenario_id, offset=0, limit=0): try: error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """select urbper_indicator_area_den_avg({scenario},{offset},{limit})""".format( scenario=scenario_id, offset=offset, limit=limit) LogEvents("area density avg", "area density avg module started: " + query, scenario_id, self.__user) conn = psycopg2.connect(self.__Indicator.get_uri()) cursor = conn.cursor( cursor_factory=psycopg2.extras.DictCursor) old_isolation_level = conn.isolation_level conn.set_isolation_level(0) cursor.execute(query) conn.commit() conn.set_isolation_level(old_isolation_level) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) LogEvents( "area density avg", "area density avg module failed " + str(count) + ": " + str(e), scenario_id, self.__user, True) conn.close() else: error = False LogEvents("area density avg", "area density avg module finished", scenario_id, self.__user) conn.close() except Exception as e: LogEvents("Running scenarios", "Unknown error " + str(e), scenario_id, self.__user, True)
def __urbper_base_footprint_area(self): try: error = True count = 0 while error and count < 3: try: self.__Indicator = Indicator(self.__user) query = """select urbper_indicator_footprints_area({scenario})""".format( scenario=self.__scenario) LogEvents("footprints area", "footprints area module started: " + query, self.__scenario, self.__user) conn = psycopg2.connect(self.__Indicator.get_uri()) cursor = conn.cursor( cursor_factory=psycopg2.extras.DictCursor) old_isolation_level = conn.isolation_level conn.set_isolation_level(0) cursor.execute(query) conn.commit() conn.set_isolation_level(old_isolation_level) except Exception as e: conn.rollback() conn.close() error = True count += 1 time.sleep(randint(1, 3)) LogEvents( "footprints area", "footprints area module failed " + str(count) + ": " + str(e), self.__scenario, self.__user, True) else: error = False conn.close() LogEvents("footprints area", "footprints area module finished", self.__scenario, self.__user) except Exception as e: LogEvents("footprints area", "unknown error+ " + str(e), self.__scenario, self.__user, True)
def run(user, scenario, indicators): import os import time my_pid = os.getpid() print("received: ", user, scenario, indicators) try: # evaluate the scenarios LogEvents("All scenarios are ready to be evaluated", "This may take a while", -1, user) evaluate = EvaluateScenario(user, scenario, indicators) LogEvents("All scenarios are ready to be evaluated", "This may take a while", -1, user) evaluate.run_scenarios() LogEvents("All scenarios have been evaluated", "You must provide arguments", -1, user) except Exception as e: LogEvents("There was an error during scenario evaluation", str(e), -1, user)
def run(self): try: self.__Indicator = Indicator(self.__user) road_classes = self.__getClassess("allseason") road_classes_array = "'{" + ",".join(road_classes) + "}'" error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_road_all_season_proximity({scenario},'pop_prox_allseason','allseason_prox',{road_class}) """.format(scenario=self.__scenario, road_class=road_classes_array) LogEvents("all season roads", "all season roads module started: " + query, self.__scenario, self.__user) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "all season roads", "all season roads module failed " + str(count) + ": " + str(e), self.__scenario, self.__user) else: error = False db.close() LogEvents("all season roads", "all season roads module finished", self.__scenario, self.__user) except Exception as e: LogEvents("all season roads", "unknown error " + str(e), self.__scenario, self.__user)
def run(self): try: self.__Indicator = Indicator(self.__user) self.__db = self.__Indicator.get_up_calculator_connection() vacuum(self.__Indicator.get_uri(), "mmu") self.__db.close() error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: query = """ select urbper_indicator_pop_transit_prox({scenario},'pop_prox_{fclass}'::varchar(30),'{fclass}_proximity'::varchar(30)) """.format(scenario=self.__scenario, fclass='transit') LogEvents("transit proximity", "transit proximity module started: " + query, self.__scenario, self.__user) with transaction.atomic(): db.execute(query) except Exception as e: error = True count += 1 time.sleep(randint(1, 3)) db.close() LogEvents( "transit proximity", "transit proximity module failed " + str(count) + ": " + str(e), self.__scenario, self.__user) else: error = False db.close() LogEvents("transit proximity", "transit proximity module finished", self.__scenario, self.__user) except Exception as e: LogEvents("transit proximity", "unknown error " + str(e), self.__scenario, self.__user)
def run_scenarios(self): try: LogEvents("Start scenario", "Starting all scenarios proccesing", self.base_scenario, self.user) last = 0 # Evaluate the scenario(s) for scenario in self.scenarios: last = scenario LogEvents( "Start scenario", "The modules to be use are: " + str(",".join(self.indicators)), scenario, self.user) ########################################## for module in self.indicators: module_r = "plup.indicators." + module + "." + module try: plugin = importlib.import_module(module_r, ".") module = plugin.Module( self.user, scenario, dict(base_scenario=self.base_scenario)) module.run() except Exception as e: print("E", e) LogEvents("Finish scenario", "The scenario have been processed", scenario, self.user) db = config.get_db() vacuum(self.indicator.get_uri(), "mmu") db.close() db = config.get_db() vacuum(self.indicator.get_uri(), True) db.close() LogEvents("All scenarios Finished", "All scenarios have been processed", last, self.user) except Exception as e: LogEvents("Unknown error", str(e), self.base_scenario, self.user)
def __urbper_base_total_population(self): try: error = True count = 0 while error and count < 3: self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() try: with transaction.atomic(): self.__Indicator = Indicator(self.__user) db = self.__Indicator.get_up_calculator_connection() query = """select urbper_indicator_base_calculus_total_population({scenario},{base_scenario})""".format( scenario=self.__scenario, base_scenario=self.__base_scenario) LogEvents("total population", "total population module started: " + query, self.__scenario, self.__user) db.execute(query) except Exception as e: db.close() error = True count += 1 time.sleep(randint(1, 3)) LogEvents( "total population", "total population module failed " + str(count) + ": " + str(e), self.__scenario, self.__user, True) else: error = False db.close() LogEvents("total population", "total population module finished", self.__scenario, self.__user) except Exception as e: LogEvents("total population", "unknown error " + str(e), self.__scenario, self.__user, True)
try: # evaluate the scenarios LogEvents("All scenarios are ready to be evaluated", "This may take a while", -1, user) evaluate = EvaluateScenario(user, scenario, indicators) LogEvents("All scenarios are ready to be evaluated", "This may take a while", -1, user) evaluate.run_scenarios() LogEvents("All scenarios have been evaluated", "You must provide arguments", -1, user) except Exception as e: LogEvents("There was an error during scenario evaluation", str(e), -1, user) if __name__ == '__main__': # sys.argv[1] user_id # sys.argv[2] list of scenarios, # sys.argv[3] list of modules if len(sys.argv) < 4: print("Wrong arguments\nExample") print( "\tEvaluateScenario user_id[1] scenarios[1_2_3_...] indicators[GeneralCalculus_AmenityProximity]" ) elif len(sys.argv) <= 2: LogEvents("Evaluate scenarios", "You must provide arguments", -1, sys.argv[1]) elif len(sys.argv) == 4: print("Running") run(sys.argv[1], sys.argv[2], sys.argv[3])