def load_config(self):
try:
with open("config.yaml") as f:
configs = yaml.safe_load(f)
self._id = configs['downloaders']['reddit']['id']
self._secret = configs['downloaders']['reddit']['secret']
self._useragent = configs['downloaders']['reddit']['useragent']
self._user = configs['downloaders']['reddit']['user']
self._password = configs['downloaders']['reddit']['password']
self._subreddits = configs['downloaders']['reddit'][
'subreddits']
self._download_batch_size = configs['downloaders']['reddit'][
'params']['download_batch_size']
self._time_refresh_sub = configs['downloaders']['reddit'][
'params']['time_refresh_sub']
self._max_log_size = configs['downloaders']['reddit'][
'params']['max_log_size']
self._media_filepath = configs['params']['media_filepath']
except EnvironmentError as e:
print("Error when opening config. ", e)
utils.error_log('RedditDownloader', "Error when opening config", e)
except KeyError as e:
print("Error when applying config. ", e)
utils.error_log('RedditDownloader', "Error when applying configs",
e)
def copiar_datos_buffer(buffer_incendios, buffer_visor):
"""Copia los resultados del buffer temporal al buffer visor."""
try:
arcpy.AddMessage("Actualizando capa de buffers...")
utils.log("Actualizando capa de buffers")
fc_origen = os.path.join(folder_local, buffer_incendios)
fc_destino = os.path.join(arcpy.env.workspace, dataset, buffer_visor)
fields = [
'id_incendio', 'nombre_incendio', 'comuna_incendio',
'superficie_incendio', 'estado_incendio', 'fecha_inicio_incendio',
'fecha_actualizacion', 'informado', 'BUFF_DIST', 'ORIG_FID',
'SHAPE@'
]
insert_cursor = arcpy.da.InsertCursor(fc_destino, fields)
with arcpy.da.SearchCursor(fc_origen, fields) as cursor:
for row in cursor:
insert_cursor.insertRow(
(row[0], row[1], row[2], row[3], row[4], row[5], row[6],
row[7], row[8], row[9], row[10]))
# Delete cursor object
del cursor
del insert_cursor
except:
print("Failed copiar_datos_buffer (%s)" % traceback.format_exc())
utils.error_log("Failed copiar_datos_buffer (%s)" %
traceback.format_exc())
def get_muestras(estaciones, fecha_hoy, hhmm):
"""Retorna la muestra por cada una de las vaiables consultadas."""
try:
muestras = []
# Hago el llamado a la api por cada estacion para consultar la direccion del viento
for estacion in estaciones:
print('Consultando estacion: {0}, {1}'.format(estacion['nombre'], estacion['comuna']))
direccion_viento = get_data_variable(estacion['id_direccion_viento'], fecha_hoy, hhmm)
# humedad_media = get_data_variable(estacion['id_humedad_media'], fecha_hoy, hhmm)
# temperatura_media = get_data_variable(estacion['id_temperatura_media'], fecha_hoy, hhmm)
# velocidad_viento_max = get_data_variable(estacion['id_velocidad_viento_max'], fecha_hoy, hhmm)
# velocidad_viento_media = get_data_variable(estacion['id_velocidad_viento_media'], fecha_hoy, hhmm)
muestras.append({
"id_estacion": int(estacion['id_estacion']),
"direccion_viento": float(direccion_viento)
# "humedad_media": float(humedad_media),
# "temperatura_media": float(temperatura_media),
# "velocidad_viento_max": float(velocidad_viento_max),
# "velocidad_viento_media": float(velocidad_viento_media)
})
return muestras
except:
print("Failed get_muestras (%s)" %
traceback.format_exc())
utils.error_log("Failed get_muestras (%s)" %
traceback.format_exc())
def ejecutar_analisis(buffer):
"""Ejecuta el análisis de intersección entre los buffers de los incendios
versus las capas de infraestructuras definidas por el cliente."""
try:
arcpy.AddMessage("Ejecutando análisis...")
utils.log("Ejecutando análisis")
incluir = const.TABLES_SIGGRE
features = arcpy.ListFeatureClasses(feature_dataset=dataset_ministerio)
for feature in incluir:
f = feature
if f in features:
#Ejecuto el cruce espacial por cada capa
in_buffer = os.path.join(arcpy.env.workspace, dataset, buffer)
in_feature = os.path.join(arcpy.env.workspace,
dataset_ministerio, f)
inFeatures = [in_buffer, in_feature]
name = f.split(user_datos)
capa_cruce = "cruce_" + name[1]
arcpy.AddMessage("Intersectando buffer contra " + f + " ...")
arcpy.AddMessage("nombre capa_cruce: " + capa_cruce + " ...")
intersectOutput = os.path.join(folder_local, capa_cruce)
arcpy.Intersect_analysis(inFeatures, intersectOutput, "", "",
'input')
except:
print("Failed ejecutar_analisis (%s)" % traceback.format_exc())
utils.error_log("Failed ejecutar_analisis (%s)" %
traceback.format_exc())
def actualizar_comunas(comunas):
"""Actualiza el nombre de la comuna en la capa."""
try:
fc = os.path.join(arcpy.env.workspace, dataset, capa_comunas)
features = []
with arcpy.da.UpdateCursor(fc,
['OID@', 'NOM_SAIDI', 'NOM_SEC']) as cursor:
for row in cursor:
for comuna in comunas:
if comuna == row[1]:
row[2] = comuna
features.append({
"attributes": {
"objectId": row[0],
"NOM_SEC": comuna,
}
})
print('Comuna de {0} actualizada'.format(comuna))
cursor.updateRow(row)
del cursor
print('features: ', features)
except:
print("Failed actualizar_comunas (%s)" % traceback.format_exc())
utils.error_log("Failed actualizar_comunas (%s)" %
traceback.format_exc())
def run(self):
while True:
try:
if Master.finished():
break
task = Master.get_task()
if not task: # no task, sleep.
time.sleep(self.sleep_time)
self.sleep_count += 1
if self.max_sleep_times > 0 and self.sleep_count >= self.max_sleep_times: # still no task for a long time, close task.
break
continue
task_type, url = task
res = urllib2.urlopen(url).read()
if task_type == Master.TASK_TYPE_IMAGE:
file_name = urlparse.urlparse(url).path.strip("/").replace("/", "_")
output_file = os.path.join(self.output_path, file_name)
if Master.finished(): break
open(output_file, "wb").write(res)
elif task_type == Master.TASK_TYPE_URL:
parser = urlparse.urlparse(url)
base_url = parser.scheme + "://" + parser.netloc
tasks = self.html_parser.parser_html(base_url, res)
if Master.finished(): break
map(lambda t: Master.push_task(t), tasks)
Master.finish_task(task)
self.sleep_count = 0
except Exception as e:
error_log("worker %d error: %s\n%s"%(self.worker_number, e, traceback.format_exc()))
if task: Master.push_task(task)
if self.error_count > self.retry_times:
break
else:
continue
info_log("worker %d stop"%self.worker_number)
def obtener_clientes_afectados(url):
"""Retorna los clientes afectados por cortes electricos por comunas."""
try:
ahora = datetime.now()
hace_20_min = ahora - timedelta(minutes=20)
anio = hace_20_min.strftime('%Y')
mes = hace_20_min.strftime('%m')
dia = hace_20_min.strftime('%d')
hora = hace_20_min.strftime('%H')
raw_data = {"anho": anio, "mes": mes, "dia": dia, "hora": hora}
print('url: ', url)
print('raw_data: ', raw_data)
response = utils.post_request_json_raw_data(url, raw_data)
return response
except:
print("Failed obtener_clientes_afectados (%s)" %
traceback.format_exc())
utils.error_log("Failed obtener_clientes_afectados (%s)" %
traceback.format_exc())
utils.log(
"No se pudo obtener el listado de clientes afectados, respuesta del servicio: "
+ str(response))
def agrupar_por_correo(instalaciones):
"""Agrupo por mail (E_MAIL) la data de las instalaciones afectadas."""
try:
data = {}
correos = []
# Obtengo un listado único de correos
for instalacion in instalaciones:
if ((instalacion['e_mail'] not in correos)
and (instalacion['e_mail'] != '')):
correos.append(instalacion['e_mail'])
data[instalacion['e_mail']] = {
'instalaciones': [],
}
print('correos unicos: ', correos)
# Recorro las instalaciones afectadas y las agrupo por correo
for instalacion in instalaciones:
if instalacion['e_mail'] in correos:
data[instalacion['e_mail']]['instalaciones'].append(
instalacion)
return data
except:
print("Failed agrupar_por_correo (%s)" % traceback.format_exc())
utils.error_log("Failed agrupar_por_correo (%s)" %
traceback.format_exc())
def agrupar_data_por_incendio(instalaciones):
"""Agrupo por incendio (id_incendio) la data de las instalaciones afectadas."""
try:
data = {}
incendios = []
# Obtengo un listado único de incendios
for instalacion in instalaciones:
if ((instalacion['id_incendio'] not in incendios)
and (instalacion['id_incendio'] != '')):
incendios.append(instalacion['id_incendio'])
data[instalacion['id_incendio']] = {
'comuna': instalacion['comuna_incendio'],
'superficie': instalacion['superficie_incendio'],
# 'near_dist': instalacion['near_dist'],
'instalaciones': [],
}
print('incendios unicos: ', incendios)
# Recorro las instalaciones afectadas y las agrupo por correo
for instalacion in instalaciones:
if instalacion['id_incendio'] in incendios:
data[instalacion['id_incendio']]['instalaciones'].append(
instalacion)
return data
except:
print("Failed agrupar_data_por_incendio (%s)" % traceback.format_exc())
utils.error_log("Failed agrupar_data_por_incendio (%s)" %
traceback.format_exc())
def enviar_email_admin_extinguido(id_incendio, comuna_incendio, subject,
fecha_inicio_incendio, nombre_incendio):
try:
# Construyo los encabezados
message = MIMEMultipart("alternative")
message["Subject"] = subject
message["From"] = email_from
message["To"] = destinatario_admin
# Construyo el cuerpo del correo en HTML
# Obtengo el template para el envío de correo a una empresa
html = template.get_template_admin_extinguido(id_incendio,
comuna_incendio,
fecha_inicio_incendio,
nombre_incendio)
part = MIMEText(html, "html")
message.attach(part)
# Envío el correo
send(destinatario_admin, message)
except:
print("Failed enviar_email_admin_extinguido (%s)" %
traceback.format_exc())
utils.error_log("Failed enviar_email_admin_extinguido (%s)" %
traceback.format_exc())
def test_mail():
"""Permite probar envío de email."""
try:
utils.log("Inicio test mail")
print("Inicio test mail")
utils.log("Enviando mail desde {} a {}".format(email_from, destinatario_admin))
print("Enviando mail desde {} a {}".format(email_from, destinatario_admin))
# Construyo los encabezados
message = MIMEMultipart("alternative")
message["Subject"] = "Test mail"
message["From"] = email_from
message["To"] = destinatario_admin
# Construyo el cuerpo del correo en HTML
# Obtengo el template para el envío de correo a una empresa
html = template.get_template_empresa('<b>Texto de prueba...</b>', 'test')
part = MIMEText(html, "html")
message.attach(part)
# Envío el correo
email.send(destinatario_admin, message)
utils.log("Fin test mail\n")
print("Fin test mail\n")
except:
print("Failed test_mail (%s)" %
traceback.format_exc())
utils.error_log("Failed test_mail (%s)" %
traceback.format_exc())
def obtener_variables_agromet(url_agromet, userkey_agromet):
"""Obtiene las variable direccion del viento, temperatura, humedad de cada una de las estaciones meteorológicas."""
try:
# Obtengo las estaciones meteorológicas
fc = os.path.join(arcpy.env.workspace, dataset, capa_estaciones_meteorologicas)
estaciones = []
muestras = []
ahora = datetime.now()
fecha_hoy = str(ahora.strftime('%Y-%m-%d'))
# A la hora actual, le resto 20 minutos ya que es el tiempo de actualizacion del servicio de agromet
hace_20_min = ahora - timedelta(minutes=20)
hhmm = hace_20_min.strftime('%H%M')
print('Fecha y hora consultada: {0} - {1} '.format(fecha_hoy, hhmm))
utils.log("Fecha y hora consultada: {0} - {1} ".format(fecha_hoy, hhmm))
with arcpy.da.SearchCursor(fc, ['id', 'id_direccion_viento', 'id_humedad_media', 'id_temperatura_media', 'id_velocidad_viento_max', 'id_velocidad_viento_media', 'nombre', 'comuna']) as cursor:
for row in cursor:
estaciones.append({
"id_estacion": row[0],
"id_direccion_viento": row[1],
"id_humedad_media": row[2],
"id_temperatura_media": row[3],
"id_velocidad_viento_max": row[4],
"id_velocidad_viento_media": row[5],
"nombre": row[6],
"comuna": row[7],
})
del cursor
# Obtengo las muestras por cada variable
muestras = get_muestras(estaciones, fecha_hoy, hhmm)
# Por cada estacion, actualizo el valor de la direccion del viento 'direccion_viento' y la fecha de actualizacion 'fecha_actualizacion'
with arcpy.da.UpdateCursor(fc, ['id', 'direccion_viento', 'fecha_actualizacion']) as cursor:
# with arcpy.da.UpdateCursor(fc, ['id', 'direccion_viento', 'humedad_media', 'temperatura_media', 'velocidad_viento_max', 'velocidad_viento_media', 'fecha_actualizacion']) as cursor:
for row in cursor:
for k in muestras:
if row[0] == k['id_estacion']:
row[1] = k['direccion_viento']
# row[2] = k['humedad_media']
# row[3] = k['temperatura_media']
# row[4] = k['velocidad_viento_max']
# row[5] = k['velocidad_viento_media']
row[2] = ahora
print('Estacion: {0}, direccion viento: {1}'.format(
k['id_estacion'], k['direccion_viento']))
cursor.updateRow(row)
del cursor
except:
print("Failed obtener_variables_agromet (%s)" %
traceback.format_exc())
utils.error_log("Failed obtener_variables_agromet (%s)" %
traceback.format_exc())
def send(to, message):
try:
if enviar_mail == 'true':
# Creo el objeto para el envío del correo
server = smtplib.SMTP(smtp_server)
server.starttls()
server.login(username, password)
server.sendmail(username, to, message.as_string())
server.quit()
except:
print("Failed send (%s)" % traceback.format_exc())
utils.error_log("Failed send (%s)" % traceback.format_exc())
def _load_config(self):
try:
with open("config.yaml") as f:
configs = yaml.safe_load(f)
self._max_aspect_ratio = configs['params']['max_aspect_ratio']
self._min_aspect_ratio = configs['params']['min_aspect_ratio']
#self._max_gif_duration = configs['params']['max_gif_duration']
#
except EnvironmentError as e:
print("Error when opening config. ",e)
utils.error_log('DownloaderThread',"Error when opening config", e)
except KeyError as e:
print("Error when applying config. ",e)
utils.error_log('DownloaderThread',"Error when applying configs", e)
def limpiar_data_local():
"""Limpia los regultados anteriores, deja en cero la cantidad de afectados, porcentaje y fecha de actualización."""
try:
fc = os.path.join(arcpy.env.workspace, dataset, capa_comunas)
with arcpy.da.UpdateCursor(
fc, ['CLI_AFECTADOS', 'PORC_AFECTADOS', 'FECHA_ACTUALIZACION'
]) as cursor:
for row in cursor:
row[0] = 0
row[1] = 0
row[2] = None
cursor.updateRow(row)
del cursor
except:
print("Failed limpiar_data_local (%s)" % traceback.format_exc())
utils.error_log("Failed limpiar_data_local (%s)" %
traceback.format_exc())
def insert_data_local(capa_local, datos, es_punto=None):
"""Guarda en las capas de resultados las entidades afectadas."""
try:
fields = [
'leyenda', 'nombre', 'propietario', 'direccion', 'criticidad',
'estado', 'estado_inf', 'e_mail', 'capa', 'id_incendio',
'nombre_incendio', 'comuna_incendio', 'superficie_incendio',
'estado_incendio', 'fecha_inicio_incendio', 'SHAPE@'
]
fc = os.path.join(arcpy.env.workspace, dataset, capa_local)
cursor = arcpy.da.InsertCursor(fc, fields)
out_sr = arcpy.SpatialReference("WGS 1984")
for dato in datos:
if es_punto != None:
point = arcpy.Point(float(dato['longitud']),
float(dato['latitud']))
geometry = arcpy.PointGeometry(point, out_sr)
else:
# for feature in dato['shape']['paths']:
# # # Create a Polyline object based on the array of points
# # # Append to the list of Polyline objects
# # geometry = arcpy.Polyline(arcpy.Array([arcpy.Point(*coords) for coords in feature]))
# array = arcpy.Array([arcpy.Point(*coords) for coords in feature])
geometry = dato['shape']
cursor.insertRow(
(dato['leyenda'], dato['nombre'], dato['propietario'],
('direccion' in dato and dato['direccion']
or ''), ('criticidad' in dato and dato['criticidad']
or ''), ('estado' in dato and dato['estado'] or ''),
('estado_inf' in dato and dato['estado_inf']
or ''), dato['e_mail'], dato['capa'], dato['id_incendio'],
dato['nombre_incendio'], dato['comuna_incendio'],
dato['superficie_incendio'], dato['estado_incendio'],
dato['fecha_inicio_incendio'], geometry))
del cursor
except:
print("Failed insert_data_local (%s)" % traceback.format_exc())
utils.error_log("Failed insert_data_local (%s)" %
traceback.format_exc())
def actualizar_clientes_afectados_local(clientes_afectados):
"""Actualiza los clientes afectados por comuna en la capa local, además calcula el porcentaje."""
try:
fc = os.path.join(arcpy.env.workspace, dataset, capa_comunas)
ahora = datetime.now()
total_clientes = 0
comunas = []
comunas_encontradas = []
with arcpy.da.UpdateCursor(fc, [
'NOM_SEC', 'CLI_SAIDI', 'CLI_AFECTADOS', 'PORC_AFECTADOS',
'FECHA_ACTUALIZACION'
]) as cursor:
for row in cursor:
for k in clientes_afectados:
comunas.append(k['NOMBRE_COMUNA'])
if row[0] == k['NOMBRE_COMUNA']:
comunas_encontradas.append(k['NOMBRE_COMUNA'])
# Actualizo los clientes afectados
row[2] = row[2] + k['CLIENTES_AFECTADOS']
total_clientes += row[2]
# Calculo el porcentaje que representa los afectados versus el total de clientes
porcentaje = row[2] / row[1] * 100
row[3] = porcentaje
row[4] = ahora
cursor.updateRow(row)
print('Comuna: {0}, clientes afectados: {1} ({2}%)'.
format(k['NOMBRE_COMUNA'], row[2], porcentaje))
del cursor
# Nombres de comunas que entrega la sec que no están registradas en la capa de comunas
comunas_nuevas = list(set(comunas) - set(comunas_encontradas))
print('comunas nuevas: ', comunas_nuevas)
# Actualizo el nombre de la comuna en la tabla
if (len(comunas_nuevas) > 0):
actualizar_comunas(comunas_nuevas)
return total_clientes
except:
print("Failed actualizar_clientes_afectados_local (%s)" %
traceback.format_exc())
utils.error_log("Failed actualizar_clientes_afectados_local (%s)" %
traceback.format_exc())
def crear_buffer(capa_incendios):
"""Crea un buffer por cada uno de los incendios."""
try:
arcpy.AddMessage("Creando buffer...")
utils.log("Creando buffer")
# roads = capa_incendios
buffer_output = capa_buffer_incendios
# roadsBuffer = os.path.join(arcpy.env.workspace, buffer_output)
roadsBuffer = os.path.join(folder_local, buffer_output)
roads = os.path.join(arcpy.env.workspace, dataset, capa_incendios)
# print('roadsBuffer: ', roadsBuffer)
# print('roads: ', roads)
distanceField = "2 Kilometers"
arcpy.Buffer_analysis(roads, roadsBuffer, distanceField)
except:
print("Failed crear_buffer (%s)" % traceback.format_exc())
utils.error_log("Failed crear_buffer (%s)" % traceback.format_exc())
def obtener_resultados():
"""Obtiene los resultados de los puntos y lineas afectadas"""
try:
arcpy.AddMessage("Obteniendo resultados de entidades afectadas...")
utils.log("Obteniendo resultados de entidades afectadas")
# Puntos
puntosAfectados = obtener_puntos_afectados()
# Lineas
lineasAfectadas = obtener_lineas_afectadas()
# Correos de alertas a enviar
entidades = puntosAfectados + lineasAfectadas
return entidades
except:
print("Failed obtener_resultados (%s)" % traceback.format_exc())
utils.error_log("Failed obtener_resultados (%s)" %
traceback.format_exc())
def _load_config(self):
try:
with open("config.yaml") as f:
configs = yaml.safe_load(f)
self._max_queue_size = configs['params']['max_queue_size']
self._image_duration = configs['params']['image_duration']
self._time_delay_text = configs['params']['time_delay_text']
self._media_filepath = configs['params']['media_filepath']
self._title_font_size = configs['params']['title_font_size']
self._min_gif_duration = configs['params']['min_gif_duration']
self._max_gif_duration = configs['params']['max_gif_duration']
self._gif_iterations = configs['params']['gif_iterations']
except EnvironmentError as e:
print("Error when opening config. ", e)
utils.error_log('MainApplication', "Error when opening config", e)
except KeyError as e:
print("Error when applying config. ", e)
utils.error_log('MainApplication', "Error when applying configs",
e)
def ejecutar_cercania(in_features):
"""Ejecuta la cercania de las instalaciones afectadas (puntos y lineas) respecto del incendio."""
try:
arcpy.AddMessage("Ejecutando cercanía..." + in_features)
utils.log("Ejecutando cercanía " + in_features)
# set local variables
near_features = [capa_incendios]
# find features only within search radius
search_radius = "5,5 Kilometers"
# find location nearest features
location = "NO_LOCATION"
# avoid getting angle of neares features
angle = "NO_ANGLE"
method = "GEODESIC"
# execute the function
arcpy.Near_analysis(in_features, near_features, search_radius,
location, angle, method)
except:
print("Failed ejecutar_cercania (%s)" % traceback.format_exc())
utils.error_log("Failed ejecutar_cercania (%s)" %
traceback.format_exc())
def informar_incendios_extinguidos():
"""Informa al admin que el incendio se ha extinguido, cuando no existe ningún incendio registrado por conaf."""
try:
arcpy.AddMessage("Enviando alerta de incendio extinguido...")
fc = os.path.join(arcpy.env.workspace, dataset, capa_incendios)
with arcpy.da.SearchCursor(fc, [
"id_incendio", "fecha_inicio_incendio", "comuna_incendio",
"nombre_incendio"
]) as cursor:
for row in cursor:
# Envío la alerta
utils.log(
"Informando incendio extingido id: {0}, comuna de {1}, fecha: {3}"
.format(row[0], row[2], row[1]))
utils.enviar_correo_admin_extinguido(row[0], row[1], row[2],
row[3])
del cursor
except:
print("Failed informar_incendios_extinguidos (%s)" %
traceback.format_exc())
utils.error_log("Failed informar_incendios_extinguidos (%s)" %
traceback.format_exc())
def run(self):
while True:
try:
if Master.finished():
break
task = Master.get_task()
if not task: # no task, sleep.
time.sleep(self.sleep_time)
self.sleep_count += 1
if self.max_sleep_times > 0 and self.sleep_count >= self.max_sleep_times: # still no task for a long time, close task.
break
continue
task_type, url = task
res = urllib2.urlopen(url).read()
if task_type == Master.TASK_TYPE_IMAGE:
file_name = urlparse.urlparse(url).path.strip("/").replace(
"/", "_")
output_file = os.path.join(self.output_path, file_name)
if Master.finished(): break
open(output_file, "wb").write(res)
elif task_type == Master.TASK_TYPE_URL:
parser = urlparse.urlparse(url)
base_url = parser.scheme + "://" + parser.netloc
tasks = self.html_parser.parser_html(base_url, res)
if Master.finished(): break
map(lambda t: Master.push_task(t), tasks)
Master.finish_task(task)
self.sleep_count = 0
except Exception as e:
error_log("worker %d error: %s\n%s" %
(self.worker_number, e, traceback.format_exc()))
if task: Master.push_task(task)
if self.error_count > self.retry_times:
break
else:
continue
info_log("worker %d stop" % self.worker_number)
def _find_new_image(self, log, sub):
'''
Compares the log of downloaded images, and compares it with the metadata dictionary.
Return the first item that is not in the log.
:return: Media object
'''
try:
for submission in self._dict_metadata[sub][1]:
file_format = submission.url.split('.')[-1]
valid_url = file_format in self._supported_image_formats
if not valid_url:
continue
elif submission.id not in log:
file_name = '{0}.{1}'.format(submission.id, file_format)
file_path = os.path.join(self._media_filepath, file_name)
self._last_image_found = utils.Media(
id=submission.id,
filetype=file_format,
filepath=file_path,
title=submission.title,
url=submission.url,
top_comment=self._get_top_comment(submission),
source='/r/{0}'.format(sub),
)
print("Found image not in log ", self._last_image_found.id)
return self._last_image_found
return None
except OAuthException as e:
print("Error in credentials for RedditDownloader")
utils.error_log('RedditDownloader', "Check config", e)
return None
except ClientException as e:
print("Error in credentials for RedditDownloader")
utils.error_log('RedditDownloader', "Check config", e)
return None
def _save_image(self, media):
'''
Checks if the provided URL is direct image link
Checks if we have downloaded it before
Returns post_id if successfully wrote image to file
Returns None if error occurred
'''
try:
img_data = requests.get(media.url).content
with open(
os.path.join(self._media_filepath,
'{0}.{1}'.format(media.id, media.filetype)),
'wb') as handler:
handler.write(img_data)
return media
except Exception as e:
utils.error_log('RedditDownloader', 'Error when downloading image',
e)
utils.log(downloader=self._downloader,
list=self._downloaded_ids,
id=media.id,
max_log_size=self._max_log_size)
return None
def get_data_variable(idEmaVariable, fecha_hoy, hhmm):
"""Retorna el valor de una variable."""
try:
value = 0
url = url_agromet + 'muestras/?idEmaVariable=' + str(idEmaVariable) + '&desde=' + \
fecha_hoy + '&hasta=' + fecha_hoy + \
'&user='******'muestras'] != None:
largo = len(data['muestras'])
if largo > 0:
last = largo - 1
value = data['muestras'][last]['valor']
return value
except:
print("Failed get_data_variable (%s)" %
traceback.format_exc())
utils.error_log("Failed get_data_variable (%s)" %
traceback.format_exc())
def generar_alertas(entidades):
"""
Se envia solo un correo por incendio.
Envío una alerta a cada correo afectada por un incendio.
Se envia el listado completo de las infraestructuras afectadas de la empresa.
Se utiliza el correo electrónico registrado por cada infraestructura para agrupar.
Se envia un resumen de los incendios e infraestructuras afectadas al ministerio de energia.
"""
try:
arcpy.AddMessage("Generando alertas...")
utils.log("Generando alertas")
print('cantidad entidades: ', len(entidades))
if len(entidades) > 0:
# Agrupo la data por id_incendio
data_por_incendio = agrupar_data_por_incendio(entidades)
# Recorro la data agrupada por incendio y la vuelvo a agrupar por correo
for incendio in data_por_incendio:
id_incendio = incendio
comuna_incendio = data_por_incendio[incendio]['comuna']
superficie = data_por_incendio[incendio]['superficie']
fc = os.path.join(arcpy.env.workspace, dataset, capa_incendios)
with arcpy.da.SearchCursor(
fc,
["id_incendio", "informado", "nombre_incendio"]) as cursor:
for row in cursor:
# Envío alertas a los incendios que no se han informado.
if row[0] == id_incendio and row[1] != True:
nombre_incendio = row[2]
# Envío por cada incendio, una alerta al ministerio de energía con el resumen de todas las instalaciones afectadas.
# aca no debo considerar los incendios ya informados.
utils.enviar_correo_admin(
id_incendio, comuna_incendio, superficie,
data_por_incendio[incendio]['instalaciones'],
nombre_incendio)
# Para el caso de las empresas, agrupo la data por email
data_por_correo = agrupar_por_correo(
data_por_incendio[incendio]['instalaciones'])
if bool(data_por_correo):
for correo in data_por_correo:
# Por cada correo registrado, envío una alerta con todas las instalaciones afectadas.
utils.enviar_correo_empresa(
correo, id_incendio, comuna_incendio,
superficie, data_por_correo[correo]
['instalaciones'], nombre_incendio)
# Actualizo el incendio a informado.
with arcpy.da.UpdateCursor(
fc,
['id_incendio', 'informado']) as cursor_update:
for row_u in cursor_update:
if row_u[0] == id_incendio:
row_u[1] = True
cursor_update.updateRow(row_u)
del cursor_update
del cursor
except:
print("Failed generar_alertas (%s)" % traceback.format_exc())
utils.error_log("Failed generar_alertas (%s)" % traceback.format_exc())
def obtener_lineas_afectadas():
"""Permite obtener las lineas afectadas por el incendio."""
try:
fields = [
'id_incendio',
'leyenda',
'nombre',
'propietario',
'direccion',
'criticidad',
'estado',
'estado_inf',
'e_mail',
'capa',
'nombre_incendio',
'comuna_incendio',
'superficie_incendio',
'estado_incendio',
'fecha_inicio_incendio',
# 'near_fid',
# 'near_dist',
'SHAPE@JSON'
]
fc = os.path.join(arcpy.env.workspace, dataset, capa_lineas_afectadas)
features = []
datos = []
with arcpy.da.SearchCursor(fc, fields) as cursor:
for row in cursor:
attributes = {}
attributes['id_incendio'] = row[0]
attributes['leyenda'] = row[1]
attributes['nombre'] = row[2]
attributes['propietario'] = row[3]
attributes['direccion'] = row[4]
attributes['criticidad'] = row[5]
attributes['estado'] = row[6]
attributes['estado_inf'] = row[7]
attributes['e_mail'] = row[8]
attributes['capa'] = row[9]
attributes['nombre_incendio'] = row[10]
attributes['comuna_incendio'] = row[11]
attributes['superficie_incendio'] = row[12]
attributes['estado_incendio'] = row[13]
attributes['fecha_inicio_incendio'] = str(row[14])
# attributes['near_fid'] = row[15]
# attributes['near_dist'] = row[16]
features.append({
"geometry": json.loads(row[15]),
"attributes": attributes
})
datos.append(attributes)
# Delete cursor object
del cursor
print('Lineas afectadas: ', len(features))
return datos
except:
print("Failed obtener_lineas_afectadas (%s)" % traceback.format_exc())
utils.error_log("Failed obtener_lineas_afectadas (%s)" %
traceback.format_exc())
def actualizar_resultados_local_puntos():
"""
Obtiene los puntos afectados por el incendio.
Guarda los puntos en la capa "PUNTOS_AFECTADOS"
"""
try:
posiblesColumnas = [
'LEYENDA', 'NOMBRE', 'DIRECCION', 'PROPIEDAD', 'PROPIETARI',
'PROPIETARIO', 'CRITICIDAD', 'ESTADO', 'ESTADO_INF', 'E_MAIL',
'id_incendio', 'nombre_incendio', 'comuna_incendio',
'superficie_incendio', 'estado_incendio', 'fecha_inicio_incendio',
'Shape'
]
# features = arcpy.ListFeatureClasses()
features = const.TABLES_SIGGRE
incluir = const.POINT_TABLES
data = []
for f in features:
name = f.split(user_datos)
feature = "cruce_" + name[1]
# print('feature: ', feature)
if feature in incluir:
# fc = os.path.join(arcpy.env.workspace, feature)
fc = os.path.join(folder_local, feature)
if arcpy.Exists(fc):
print('actualizar_resultados_local_puntos fc: ', fc)
field_names = [f.name for f in arcpy.ListFields(fc)]
with arcpy.da.SearchCursor(fc, field_names) as cursor:
for row in cursor:
union = list(zip(field_names, row))
attributes = {}
for val in union:
if val[0] in posiblesColumnas:
if val[0] == 'Shape':
shape = val[1]
attributes['latitud'] = shape[1]
attributes['longitud'] = shape[0]
continue
if (val[0] == 'PROPIETARI'
or val[0] == 'PROPIEDAD'):
attributes['propietario'] = val[1]
continue
attributes[val[0].lower()] = (
val[1] != None and val[1] or '')
attributes['capa'] = feature.replace(
'cruce_', '')
data.append(attributes)
# Delete cursor object
del cursor
insert_data_local(capa_puntos_afectados, data, True)
except:
print("Failed actualizar_resultados_local_puntos (%s)" %
traceback.format_exc())
utils.error_log("Failed actualizar_resultados_local_puntos (%s)" %
traceback.format_exc())
def download(self):
'''
Decide what subreddit to download images from
Download image if it hasn't been shown before or downloaded to folder buffer
TODO: Refresh a subreddit from hot if we haven't done so in a while to prevent only showing old "new" images
TODO: Prevent download from a stale subreddit for some hours (Long time since a new post)
TODO: Some GIFs do not have the looping variable set, and won't loop
TODO: Images should be downloaded to a temporary folder, and then be moved if it is valid. For now, if images are not valid media, it is stored in the same folder as valid media first and then deleted.
'''
try:
self._reddit = praw.Reddit(client_id=self._id,
client_secret=self._secret,
user_agent=self._useragent,
username=self._user,
password=self._password)
except Exception as e:
utils.error_log('RedditDownloader',
"Error creating reddit praw object", e)
return None
#Create a list of numbers from 0 to num_subreddits, and shuffle the order.
idx_subs = [i for i in range(0, len(self._subreddits))]
random.shuffle(idx_subs)
#Try the first random subreddit. If no images are found, move to a new random sub.
for i in range(0, len(self._subreddits)):
sub_to_download_from = self._subreddits[idx_subs[i]]
#Check if there are images to be downloaded
time_since_refresh_seconds = (
datetime.datetime.now() -
self._dict_metadata[sub_to_download_from][0]).total_seconds()
time_since_refresh_minutes = divmod(time_since_refresh_seconds,
60)[0]
if time_since_refresh_minutes >= self._time_refresh_sub or self._find_new_image(
self._downloaded_ids, sub_to_download_from) == None:
print("Updating metadata list from ", sub_to_download_from)
self._update_metadata_list(sub_to_download_from, 'hot')
if self._find_new_image(self._downloaded_ids,
sub_to_download_from) == None:
self._update_metadata_list(sub_to_download_from, 'new')
if self._find_new_image(self._downloaded_ids,
sub_to_download_from) == None:
print(
"Could not find any images that have not been shown. Moving to another subreddit"
)
continue
#Actually download the image to an image folder
downloaded_media = self._save_image(self._last_image_found)
print(downloaded_media)
# Add parameters we don't know until image is downloaded
if type(downloaded_media) is utils.Media:
try:
downloaded_media.width, downloaded_media.height = utils.get_width_height(
downloaded_media.filepath)
if downloaded_media.filetype == 'gif':
downloaded_media.duration = utils.get_gif_duration(
downloaded_media.filepath)
print("GIF duration: ", downloaded_media.duration)
except:
utils.error_log('RedditDownloader',
'Error fetching image metadata')
utils.remove_media(downloaded_media.filepath)
return None
else:
return None
if downloaded_media.filetype == 'gif' and type(
downloaded_media.duration) is None:
utils.error_log('RedditDownloader', 'GIF duration was 0')
return None
elif type(downloaded_media.width) is None or type(
downloaded_media.height) is None:
utils.error_log('RedditDownloader',
'Width and height of image was undefined')
return None
if type(downloaded_media) == utils.Media:
utils.log(downloader=self._downloader,
list=self._downloaded_ids,
id=downloaded_media.id,
max_log_size=self._max_log_size)
return downloaded_media
else:
return None
import PIL.Image
import utils
#img = PIL.Image.open('/home/omegav/git/Blink/images/axfio9.gif')
utils.error_log('utils', 'Error removing media')
