#!/usr/bin/env python
import lxml.html as LH
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.poolmanager import PoolManager
#import ssl
#class MyAdapter(HTTPAdapter):
# def init_poolmanager(self,connections,maxsize,block=False):
# self.poolmanager = PoolManager(num_pools=connections,
# maxsize=maxsize,
# block=block,
# ssl_version=ssl.PROTOCOL_TLSv1)
import requests
import pandas as pd
from re import compile,search
from datetime import datetime, timedelta
from time import strptime,localtime,mktime,strftime
# from datetime import datetime
from sys import argv
import MySQLdb
def text(elt):
elt1 = elt.text_content()
elt2 = elt1.replace(u'\xa0', u' ')
elt3 = elt2.replace(u'\xb0', u'')
elt3 = elt3.replace(u'\u2191 ', u'')
#return elt.text_content().replace(u'\xa0', u' ')
return elt3
urlsunm = 'http://www.timeanddate.com/sun/colombia/'
urlmoom = 'http://www.timeanddate.com/moon/colombia/'
urlmood = 'http://www.timeanddate.com/astronomy/colombia/'
cities = {'cartagena':['FNC Sur','FN Caribe Sur'],\
'barranquilla':['FNC Centro','FN Caribe Centro'],\
'santa-marta':['FNC Norte','FN Caribe Norte'],\
'san-andres':['San Andres','Providencia','Norte de SAI'],\
'buenaventura':['Bahia Solano','Buenaventura','Tumaco','Area M 1 FNP','Area M 2 FNP','Area M 3 FNP'],\
'mitu':['Orinoquia1','Orinoquia2','Orinoquia3','Orinoquia4','Orinoquia5','Orinoquia6'],\
'villavicencio':['Oriente1','Oriente2','Oriente3'],\
'florencia':['Sur1','Sur2','Sur3']}
gfscit = {'Providencia':1,'San Andres':2,'FN Caribe Norte':3,\
'FN Caribe Centro':4,'FN Caribe Sur':5,'Norte de SAI':6,\
'FNC Centro':7,'FNC Sur':8,'FNC Sur':9,'Oriente1':10,\
'Oriente2':11,'Oriente3':12,'Orinoquia1':13,'Orinoquia2':14,\
'Orinoquia3':15,'Sur1':16,'Sur2':17,'Sur3':18,\
'Bahia Solano':22,'Buenaventura':23,'Tumaco':24,\
'San Felipe':25,'Puerto Narino':26, 'Arauquita':27}
proxies = {
'http': 'http://172.25.19.11:3128',
'https': 'http://172.25.19.11:3128',
}
#Fecha actual
HORA_SYS = localtime()
#HORA_SYS = localtime(mktime((HORA_SYS[0],HORA_SYS[1],HORA_SYS[2]-12,0,0,0,0,0,0))) #fecha de ayer
ANODEFA = HORA_SYS[0]
MESDEFA = HORA_SYS[1]
DIADEFA = HORA_SYS[2]
def srchInd(units,gfsidx):
#A partir del codigo de referencia gfsidx busca su codigo en unit
res_ = filter(lambda ind: ind['gfsp'] == gfsidx, units)
return res_[0]['ind'],res_[0]['tipo'] #Unidad,Tipo
# return res_[0]['ind'] #Retorna codigo principal asociado a la BD
def getUAbrv(unidcurs):
cabrev = {}
#print cities.keys()
for i,city in enumerate(cities.keys()): #ciudad
#print cities[city]
abrev =[]
for j in range(len(cities[city])): #descripcion
res_ = filter(lambda abrev: abrev['descr'] == cities[city][j], unidcurs)
abrev.append((res_[0]['abrev'],res_[0]['ind'])) #Guarda Abreviatura e indice interno de referencia
cabrev[city] = abrev
#print cities[city][j], res_
#cabrev=dict(city=abrev)
#cabrev{cities[city]}.append(abrev)
return cabrev #Retorna diccionario con la info de city,abrev
def unitID(unidcurs,unidad):
# encuentra el indice corresp a la unidad
# http://stackoverflow.com/questions/1580270/whats-the-best-way-to-search-for-a-python-dictionary-value-in-a-list-of-diction
if any(d['abrev'] == unidad for d in unidcurs):
# Obtenga el ID correspondiente a la unidad consultada
res_ = filter(lambda unit: unit['abrev'] == unidad, unidcurs)
return res_[0]['ind']
else: return None #No encontro resultado
def sunM(BD,unidads,cabrev):
# BD: conex. Base de datos COMET
# lista de tabla UNIDAD, lista
#print cabrev.keys()
for ct,k in enumerate(cabrev.keys()):
#print ct,k
print urlsunm+k
# Sun Data (monthly)
# url = 'http://www.timeanddate.com/sun/colombia/cartagena'
r = requests.get(urlsunm+k,proxies=proxies)
root = LH.fromstring(r.content)
#root = LH.fromstring(r.text)
for table in root.xpath('//table[@id="as-monthsun"]'):
header = [text(th) for th in table.xpath('//th')]
data1 = [[text(td) for td in tr.xpath('td')]
for tr in table.xpath('//tr')]
#data = [row for row in data if len(row)==len(header)]
year = header[0]
month = header[7]
sunrise = [data1[i][0][0:5] for i in range(3,len(data1)-1)]
sunset = [data1[i][1][0:5] for i in range(3,len(data1)-1)]
sunmax = [data1[i][10][0:5] for i in range(3,len(data1)-1)] #20150802: Hora de altura maxima
#print sunmax
if ct == 0:
# Extraer los dias correspondientes solo numeros {1 a 2 longitud}
dia=[]
er_num = "^\d{1,2}$"
cmp_num = compile(er_num)
for i in range(len(header)):
mo_num = cmp_num.search(header[i])
if mo_num: dia.append(header[i].zfill(2))
fsun=[]
# fsunset=[]
for i in range(len(dia)):
sFecha = year+' '+month+' '+dia[i]
fecha = strptime(sFecha,'%Y %b %d')
# sFecha = str(fecha['tm_year'])+'-'+str(fecha['tm_mon']).zfill(2)+'-'+str(fecha['tm_mday']).zfill(2)
sFecha = str(fecha[0])+'-'+str(fecha[1]).zfill(2)+'-'+str(fecha[2]).zfill(2)
fsun.append(sFecha)
# fecha = datetime.strptime(sFecha,'%Y %b %d %H:%M')
#print "returned: %s " % fsun
#Recorrer cada uno de los puntos de informacion asociados a cada ciudad con los datos recopilados
for i in range(len(cabrev[k])):
#print cabrev[k][i]
#stac = k[i] #ej: FNC_3,FNC_S,FNC_2,FNC_C...
IDstac = cabrev[k][i][1]
#IDstac = unitID(unidads,cabrev[k][i]) # Consulta por el ID corresp a la stacion
for f in range(len(fsun)):
if not BD.verificar(fsun[f],IDstac): #No Encontro un registro previo en la tabla:: Status = 0
#Insertar registros para estructuras sunrise y sunset
BD.insSunM(0,fsun[f],IDstac,sunrise[f],sunset[f],sunmax[f])
else:
BD.insSunM(1,fsun[f],IDstac,sunrise[f],sunset[f],sunmax[f])
#else: print 'Encontrado %s' % fsun[f]
#print fsun[f]
#Colocar el sistema en modo "CHANGE MONTH !!" procedimiento a efectuar con cada cambio de mes
res_ = BD.chgmonth('0',0) #Capturar el valor de chgmnth
if res_ == '1': BD.chgmonth('0',1) #Indicar que las rutinas de cambio de mes se han completado
return fsun
# print year
# print month
# print "sunrise: %s " % sunrise
# print "sunset %s " % sunset
def moonM(BD,cabrev,fmon):
####
# Moon Data
# fmon es la referencia al conjunto de fechas previamente obtenida en metodo sunM
#Expresiones Regulares
# er_date = ">(\\d{8})<"
# er_valu = ">(\\d+,\d{3})<"
# cmp_date = compile(er_date)
# cmp_valu = compile(er_valu)
er_hour = "(\\d{1,2}\:\\d{2})"
cmp_hour = compile(er_hour)
for ct,k in enumerate(cabrev.keys()):
print urlmoom+k
r = requests.get(urlmoom+k,proxies=proxies)
root = LH.fromstring(r.content)
#root = LH.fromstring(r.text)
for table in root.xpath('//table[@id="tb-7dmn"]'):
header = [text(th) for th in table.xpath('//th')]
data2 = [[text(td) for td in tr.xpath('td')]
for tr in table.xpath('//tr')]
year = header[0]
month = header[3]
#print header
#print data2
#print data2[2][2]
print "Year:", year
print "Month:", month
moondat = []
# Filtrar celdas inncesarias y guardar las que son:
# col0:
# col1:
# col2:
for i in range (2,len(data2)-1):
row = []
count=0
for j in range (len(data2[i])):
if count < 4: #Limita solo a los tres primeros datos
if data2[i][j] == '-':
row.append(data2[i][j])
count+=1
#print "Yay! un dash en",(i,j)
else:
mo_hour = cmp_hour.search(data2[i][j])
if mo_hour:
#print "Yay! Una Hora", (data2[i][j],i,j)
row.append(data2[i][j])
count+=1
else: break
moondat.append(row)
print moondat
# moondat[0] =>
for f in range(len(moondat)): #Recorre toda la estructura moondat
FMTMONM = '%H:%M' #generar una variable con el formato fijo de hora 24/12 Horas
if moondat[f][0] == '-':
if moondat[f][2] != '-':
if len(moondat[f][2]) > 5: FMTMONM = '%I:%M %p'
monort = strptime(moondat[f][2],FMTMONM) #20161104 change
else: monort = '-'
else:
if moondat[f][0] != '-':
if len(moondat[f][2]) > 5: FMTMONM = '%I:%M %p'
monort = strptime(moondat[f][0],FMTMONM) #20161104 change
else: monort = '-'
#monort = moondat[f][0]
if monort != '-': monort_ = str(monort[3]).zfill(2)+':'+str(monort[4]).zfill(2)
else: monort_ = '-'
for i in range(len(cabrev[k])):
IDstac = cabrev[k][i][1]
#stac = k[i] #ej: FNC_3,FNC_S,FNC_2,FNC_C...
# IDstac = unitID(unidads,cabrev[k][i]) # Consulta por el ID corresp a la stacion
#for f in range(len(cabrev[k][i])):
if BD.verificar(fmon[f],IDstac): #Encontro un registro previo en la tabla para poder modificarlo
#actualizar registros correspondientes para estructura moondat
if moondat[f][1] != '-':
monca = strptime(moondat[f][1],FMTMONM)
#monca_ = moondat[f][1]
monca_ = str(monca[3]).zfill(2)+':'+str(monca[4]).zfill(2)
else: monca_ = '-'
if len(moondat[f]) > 3:
if moondat[f][3] != '-':
monxal = strptime(moondat[f][3],FMTMONM)
#monxal_ = moondat[f][3]
monxal_ = str(monxal[3]).zfill(2)+':'+str(monxal[4]).zfill(2)
else: monxal_ = '-'
#BD.insMoonM(fmon[f],IDstac,monort,moondat[f][1],moondat[f][3])
else: monxal_ = '-'
BD.insMoonM(fmon[f],IDstac,monort_,monca_,monxal_)
#else: print 'Encontrado %s' % fsun[f]
#print fsun[f]
# print "Location %s, Data %s" % (k,moondat)
# print "Length %i" % len(moondat)
#print moonset
def moonD(BD,curmoonph,cabrev):
###
# Obtener fase de la luna para el dia actual (Data Diary)
# curmoonph: cursor con
for ct,k in enumerate(cabrev.keys()):
print urlmood+k
url = urlmood+k
#url = "http://www.timeanddate.com/astronomy/colombia/cartagena"
r = requests.get(url,proxies=proxies)
root = LH.fromstring(r.content)
moontxt = root.xpath('//*[@id="qlook"]/p/text()')
#moonpct = root.xpath('//*[@id="qlook"]/div/text()')
moonpct = root.xpath('//span[@id="cur-moon-percent"]/text()')
moonpct = moonpct[0][-5:-1] #Solo numeros
#print moontxt,moonpct
monDate = root.xpath('//span[@id="smct"]/text()') #4 Nov 2016, 16:54:03 / Nov 7, 2016 at 8:00:03 AM
print monDate #ValueError: time data '2016 at 4, Nov' does not match format '%Y %b %d'
### 20161108: Solucion al inconveniente del formato de fecha dual que se recibe desde moonDate (website)
if search('\w{3}\s\d+\,\s\d{4}',monDate[0]): #ej: Nov 7, 2016 at 8:00:03 AM
print "PATTERN(1) \w{3}\s\d+\,\s\d{4}"
#Obtener posicion de los espacios en la cadena moonDate para extraer: day, mont, year actual
sp1 = monDate[0].find(' ') #primer espacio que ubica el dia (cambiado el 20161104)
sp2 = monDate[0].find(' ',sp1+1)
sp3 = monDate[0].find(' ',sp2+1)
#day = monDate[0:sp1] #formato anterior (20161104)
#mont = monDate[sp1+1:sp2] #formato anterior (20161104)
monDate = monDate[0][:sp3]
mont = monDate[0:sp1]
day = monDate[sp1+1:sp2-1]
#year = monDate[sp2+1:] #viejo formato de fecha desde su URL original
year = monDate[-4:]
elif search('\d+\s\w{3}\s\d{4}\,',monDate[0]): #4 Nov 2016, 20:32:20
print "PATTERN(2) \d+\s\w{3}\s\d{4}\,"
sp1 = monDate[0].find(' ') #primer espacio que ubica el dia (cambiado el 20161104)
sp2 = monDate[0].find(' ',sp1+1)
sp3 = monDate[0].find(' ',sp2+1)
monDate = monDate[0][:sp3-1]
day = monDate[0:sp1]
mont = monDate[sp1+1:sp2]
year = monDate[-4:]
print monDate
print day
print mont
print year
#Convertir a fecha time object
sFecha = year+' '+mont+' '+day
fecha = strptime(sFecha,'%Y %b %d')
sFecha = str(fecha[0])+'-'+str(fecha[1]).zfill(2)+'-'+str(fecha[2]).zfill(2)
#Buscar en curmoonph el ID de la fase de la luna correspondiente a la descripcion del dia => moontxt
print moontxt,moonpct
res_ = filter(lambda fase: fase['descr'] == moontxt[0], curmoonph)
abrev = res_[0]['abrev']
print abrev
for i in range(len(cabrev[k])):
IDstac = cabrev[k][i][1]
if BD.verificar(sFecha,IDstac): #Encontro un registro previo en la tabla para poder modificarlo
BD.insMonPh(abrev,moonpct,sFecha,IDstac)
#print type(moonfase[0].text_content())
print k, moontxt[0], moonpct, sFecha
"""
for table in root.xpath('//table[@id="as-monthsun"]'):
#for table in root.xpath('//table[@id="sortabletable"]'):
header = [text(th) for th in table.xpath('//th')] # 1
data = [[text(td) for td in tr.xpath('td')]
for tr in table.xpath('//tr')] # 2
#data = [row for row in data if len(row)==len(header)] # 3
data = [row for row in data] # 3
#data = pd.DataFrame(data, columns=header) # 4
print(data)
#print(header)
"""
def getGFSparms(hndgfs):
gfsdat = {'NUBOSIDAD':[],'PRECIPITA':[],'TEMPERATU':[],'HUMEDAD':[],'DIRVIENTO':[],'MAGVIENTO':[],'ALTURAOLA':[]} #Diccionario para almacenar toda la info extraida de fichero de texto plano procesado por matlab previamente (Hecho por Claudia Urbano)
#gfsdat = {'NUBO':[],'PREC':[],'TEMP':[],'HUME':[],'DIRV':[],'MAGV':[],'ALTU':[]} #Diccionario para almacenar toda la info extraida de fichero de texto plano procesado por matlab previamente (Hecho por Claudia Urbano)
rgx01 = r'^\d{1,3}$|^\d{1,3}\.\d{1,8}$' #Validar numeros con o sin decimales
reCmp = compile(rgx01)
#Analiza y procesa archivo de texto obtenido desde matlab. Los datos organizados son enviados a la BD.
lines_ = hndgfs.readlines()
# if not lines_: break
for line_ in lines_:
matrx = []
lBuffer = line_.split()
if lBuffer[0] not in ("FEC","PUNTOS","DIROLA"):
for i in range(2,len(lBuffer)):
if len(lBuffer[i]) > 8: lBuffer[i] = lBuffer[i][:-1]
if reCmp.search(lBuffer[i]):
isnum = reCmp.search(lBuffer[i])
if isnum.group().find('.') != -1: #Verifica que la cadena sea (!= -1) o no decimal
num = round(float(isnum.group()),2)
else:
num = int(isnum.group())
matrx.append(num)
print lBuffer[0], len(matrx)
gfsdat[lBuffer[0]].append(matrx) #Agrega fila/vector completo matrx a gfsdat[lBuffer[0]] actual
else:
if lBuffer[0] == "FEC":
anoGFS = lBuffer[1]
mesGFS = lBuffer[2].zfill(2)
diaGFS = lBuffer[3].zfill(2)
fecGFS = anoGFS + '-' + mesGFS + '-' + diaGFS
# matrx.append(lBuffer)
# print 'Nubosidad::',gfsdat['NUBOSIDAD']
return gfsdat,fecGFS
def probrain(value):
# Obtiene el porcentaje acuerdo al promedio de lluvia para el dia o la noche (value)
if value >= 0.01 and value < 0.1:
pctg = 10
elif value >= 0.1 and value < 0.2:
pctg = 20
elif value >= 0.2 and value < 0.3:
pctg = 30
elif value >= 0.3 and value < 0.4:
pctg = 40
elif value >= 0.4 and value < 0.5:
pctg = 50
elif value >= 0.5 and value < 0.75:
pctg = 60
elif value >= 0.75 and value < 1:
pctg = 70
elif value >= 1 and value < 1.5:
pctg = 80
else: pctg = 0
return pctg
def sameMonth(fecha,lstmnth):
# 20151019: Verifica que el mes actual sea el mismo del ultimo registrado en la BD
hoymnth = int(fecha[-5:7])
lstmnth = int(lstmnth)
if hoymnth > lstmnth: return False
else: return True
def sndGFSdat(BD,units,gfsdat,fecha,opaere,lstmnth):
GFSval=[]
#20151019: Obtener el mes de la fecha y compararlo con lstmnth. Si la fecha de hoy es mayor que la de manana
igualmes = sameMonth(fecha,lstmnth)
if not igualmes: BD.chgmonth('1',1) #Esta validacion debe efectuarse con cada cambio de mes
#return
#print type(hoymnth), type(lstmnth)
#return
# toma los datos obtenidos en getGFSparmas, realiza calculos con ellos y los envia a la BD
# gfsdat: estructura que contiene la informacion extraida en getGFSparms
#print gfsdat
# Recorre toda la estructura gfsdat por cada indice estructural que contiene
for k in range(len(units)): #Recorre las k listas (unidades)
for i,var in enumerate(gfsdat.keys()): #Identifica cada variable en var: NUBOSIDAD, ALTURAOLA, PRECIPITA, TEMPERATU...
values = []
acdia = 0
acnoc = 0
GFStrc = {}
for j in range(len(gfsdat[var])): #Recorre los n vectores (que representan cada bloque: 7-13-19-25-31-37-43-49)
values.append(gfsdat[var][j][units[k]['gfsp']-1])
if j == 4: #reinicialice acumululadores acdia y acnoc
acdia = 0
acnoc = 0
if j in (0,1,4,5): #dia
acdia += gfsdat[var][j][units[k]['gfsp']-1]
# print var,j,units[k]['gfsp']-1,gfsdat[var][j][units[k]['gfsp']-1]
else: #noche
acnoc += gfsdat[var][j][units[k]['gfsp']-1]
#print var,j,units[k]['gfsp']-1
if j == 3 or j == 7:
prmdia = round(acdia/2,2)
prmnoc = round(acnoc/2,2)
GFStrc = {'var':var,'point':units[k]['gfsp'],'avgday':prmdia,'avgnht':prmnoc,'rngdat':values}
GFSval.append(GFStrc)
values = []
#print GFSval
#return
numvar = 0 #Cuenta la cantidad de variables leidas de la estructura principal por cada unidad
#print len(GFSval)
#return
for i in range(len(GFSval)): # i hasta 49 horas
if numvar == 0:
#201709i reinicializar vectores
nubos = []
precip = []
posll_d = []
posll_n = []
temp_d = []
temp_n = []
hum_d = []
hum_n = []
dirv_d = []
dirv_n = []
velv_d = []
velv_n = []
stamar = []
insert = False
code = srchInd(units,GFSval[i]['point']) #Buscar el codigo-BD representativo al punto gfs
print code
nubprec = 0
hwave = 0
# for j in range(len(gfsdat.keys())): #Recorrido de los diferentes variables/parametros presente
if GFSval[i]['var'] == 'NUBOSIDAD':
numvar+=1
nubprec+=1
nubos.append(GFSval[i]['rngdat'])
#for j in range(len(GFSval[i]['rngdat'])):
# print GFSval[i]['rngdat'][j] #rngdat value
elif GFSval[i]['var'] == 'PRECIPITA':
numvar+=1
nubprec+=1
precip.append(GFSval[i]['rngdat'])
posll_d.append(probrain(GFSval[i]['avgday']))
posll_n.append(probrain(GFSval[i]['avgnht']))
elif GFSval[i]['var'] == 'TEMPERATU':
numvar+=1
temp_d.append(GFSval[i]['avgday'])
temp_n.append(GFSval[i]['avgnht'])
elif GFSval[i]['var'] == 'HUMEDAD':
numvar+=1
hum_d.append(GFSval[i]['avgday'])
hum_n.append(GFSval[i]['avgnht'])
elif GFSval[i]['var'] == 'DIRVIENTO':
numvar+=1
dirv_d.append(GFSval[i]['avgday'])
dirv_n.append(GFSval[i]['avgnht'])
elif GFSval[i]['var'] == 'MAGVIENTO':
numvar+=1
velv_d.append(GFSval[i]['avgday'])
velv_n.append(GFSval[i]['avgnht'])
else: #ALTURAOLA (Estado del Mar)
numvar+=1
hwave+=1
if code[1] == 'M':
stamar.append(GFSval[i]['rngdat'])
if hwave == 2:
#print stamar, hwave, numvar, GFSval[i]['point']
BD.iIndMarit(fecha,code[0],stamar)
hwave == 0
#print GFSval[i],fecha,code[0],stamar
if code[1] == 'T':
if nubprec == 4 and not insert: # Lee variables de NUBOSIDAD y PRECIPITA si no las ha insertado previamente las inserta
print "fecha:%s, ind:%s, opaere:%s, nubos:%s, precip:%s" % (fecha,code[0],opaere,nubos,precip)
#print precip
BD.iIndAerea(fecha,code[0],opaere,nubos,precip)
insert = True
if numvar == 14: #(7+7)=2 dias:
#print "unit:%s tipo:%s posll_d:%s posll_n:%s temp_d:%s temp_n:%s hum_d:%s hum_n:%s dirv_d:%s dirv_n:%s velv_d:%s velv_n:%s" % \
# (code[0],code[1],posll_d,posll_n,temp_d,temp_n,hum_d,hum_n,dirv_d,dirv_n,velv_d,velv_n)
#BD.updindcrs(igualmes,fecha,code[0],posll_d,posll_n,temp_d,temp_n,hum_d,hum_n,dirv_d,dirv_n,velv_d,velv_n)
numvar = 0 # si capturo las 7var x 2dias, resetear para ubicar otro code
#Calc. Probab de lluvia a partir de una funcion y entradas posll_d y posll_n
#if not igualmes: BD.chgmonth('1');
def deltadate(sFecha,delta):
dtfecha = datetime.strptime(sFecha,'%Y-%m-%d')
fecha_ = dtfecha + timedelta(hours=delta)
return fecha_
class pronarc_db:
db = None #inicializa la variable para el manejo de la conexion a la BD
def __init__(self,dbhost):
try:
# self.db = MySQLdb.connect(user='root', passwd='lenercabeza', db='BD_Emas')
#self.db = MySQLdb.connect(host='copiapo',user='wceren', passwd='TOBLERONE50g', db='comet') #deshabilitado 20160429 por migracion a dimarbtaweb26
self.db = MySQLdb.connect(host=dbhost,user='wceren', passwd='TOBLERONE50g', db='comet')
self.cur = self.db.cursor(MySQLdb.cursors.DictCursor)
except MySQLdb.Error, (errno, strerror):
print "(%s): %s" % (errno, strerror)
def chgmonth(self,status,mode):
# 20151019: Valida el estado del cambio de mes en el sistema para comportamiento adecuado
if mode == 1: #actualiza flag
str_ = "UPDATE status SET chgmnth = %s";
self.cur.execute(str_,(status))
self.db.commit() #MariaDB requiere commit!!
return
else:
str_ = "SELECT chgmnth FROM status";
self.cur.execute(str_)
resl = self.cur.fetchone()
return resl['chgmnth']
def getlasmonth(self):
# Obtiene el ultimo mes registrado en la BD
str_ = "SELECT MONTH(fecha) FROM indicrs ORDER BY fecha DESC LIMIT 1";
self.cur.execute(str_)
resl = self.cur.fetchone() #fetch the query
return resl['MONTH(fecha)']
def getmoonph(self):
str_ = "SELECT * FROM moonphase"
self.cur.execute(str_)
resl = self.cur.fetchall() #fetch all rows
return resl
def getunits(self):
str_ = "SELECT * FROM unidad"
self.cur.execute(str_)
resl = self.cur.fetchall()
return resl
def getopaer(self):
str_ = "SELECT * FROM oper_aerea"
self.cur.execute(str_)
resl = self.cur.fetchall()
return resl
def verificar(self, fecha, unit):
str_ = "SELECT fecha, unidad, fecha FROM indicrs WHERE fecha = %s AND unidad = %s"
self.cur.execute(str_, (fecha,unit))
resl = self.cur.fetchone() #fetch the query
if resl: return True
else: return False
def insSunM(self,mode,fecha,unit,sunort,sunoca,sunmax):
#Primera secuencia ejecutada cuando se inicia un nuevo periodo
try:
if mode == 0: #Inserta nuevos registros mensuales (default)
str_ = "INSERT INTO indicrs (fecha,unidad,sol_ort,sol_oca,sol_mxalt) VALUES (%s,%s,%s,%s,%s)"
self.cur.execute(str_, (fecha,unit,sunort,sunoca,sunmax))
print str_ % (fecha,unit,sunort,sunoca,sunmax)
else: #Registros ya fueron introducidos previamente desde GFS data
#str_ = "UPDATE indicrs SET sol_ort=%s,sol_oca=%s,sol_mxalt=%s WHERE fecha=%s AND unidad=%s (%s,%s,%s,%s,%s)"
str_ = "UPDATE indicrs SET sol_ort=%s,sol_oca=%s,sol_mxalt=%s WHERE fecha='%s' AND unidad=%s"
self.cur.execute(str_, (sunort,sunoca,sunmax,fecha,unit))
print str_ % (sunort,sunoca,sunmax,fecha,unit)
except MySQLdb.Error, (errno, strerror):
print "(%s): %s" % (errno, strerror)
self.db.commit() #MariaDB requiere commit!!
return
def insMoonM(self,fecha,unit,monort,monoca,monmax):
try:
if monort != '-':
if monoca != '-': #No tiene valor en origen (-)
if monmax != '-':
str_ = "UPDATE indicrs SET lun_ort=%s,lun_oca=%s,lun_mxalt=%s WHERE fecha=%s AND unidad=%s"
print str_ % (monort,monoca,monmax,fecha,unit)
self.cur.execute(str_, (monort,monoca,monmax,fecha,unit))
else:
str_ = "UPDATE indicrs SET lun_ort=%s,lun_oca=%s WHERE fecha=%s AND unidad=%s"
print str_ % (monort,monoca,fecha,unit)
self.cur.execute(str_, (monort,monoca,fecha,unit))
else:
if monmax != '-':
str_ = "UPDATE indicrs SET lun_ort=%s,lun_mxalt=%s WHERE fecha=%s AND unidad=%s"
print str_ % (monort,monmax,fecha,unit)
self.cur.execute(str_, (monort,monmax,fecha,unit))
else:
str_ = "UPDATE indicrs SET lun_ort=%s WHERE fecha=%s AND unidad=%s"
print str_ % (monort,fecha,unit)
self.cur.execute(str_, (monort,fecha,unit))
else:
if monoca != '-':
if monmax != '-':
str_ = "UPDATE indicrs SET lun_oca=%s,lun_mxalt=%s WHERE fecha=%s AND unidad=%s"
print str_ % (monoca,monmax,fecha,unit)
self.cur.execute(str_, (monoca,monmax,fecha,unit))
else:
str_ = "UPDATE indicrs SET lun_oca=%s WHERE fecha=%s AND unidad=%s"
print str_ % (monoca,fecha,unit)
self.cur.execute(str_, (monoca,fecha,unit))
else:
if monmax != '-':
str_ = "UPDATE indicrs SET lun_mxalt=%s WHERE fecha=%s AND unidad=%s"
print str_ % (monmax,fecha,unit)
self.cur.execute(str_, (monmax,fecha,unit))
except MySQLdb.Error, (errno, strerror):
print "(%s): %s" % (errno, strerror)
self.db.commit() #MariaDB requiere commit!!
def insMonPh(self,mfase,mpct,fecha,unit):
try:
str_ = "UPDATE indicrs SET moon_f=%s, moon_p=%s WHERE fecha=%s AND unidad=%s"
print str_ % (mfase,mpct,fecha,unit)
self.cur.execute(str_, (mfase,mpct,fecha,unit))
except MySQLdb.Error, (errno, strerror):
print "(%s): %s" % (errno, strerror)
self.db.commit()
def iIndAerea(self,today,codunid,oper,cobert,precip):
rang = [7,13,19,25,31,37,43,49] #Rango de Hora x Dia Registrado (de 24 paso a 48 hrs)
print "cobert::",cobert
try:
for i in range(len(oper)): #Operaciones
r = 0
for j in range(len(cobert)): #dias de cobertura (nubosidad)
for k in range(len(cobert[j])): #vector x dia de cobertura (nubosidad)
fecha_ = deltadate(today,rang[r])
str_ = "INSERT INTO ind_aereas_ng (fecha,unidad,oper,cobert,precip) VALUES (%s,%s,%s,%s,%s)"
print str_ % (fecha_,codunid,oper[i]['code'],cobert[j][k],precip[j][k])
r+=1 #incrementa posiciones en rang
#self.cur.execute(str_, (today,codunid,oper[c]['code'],cobert[i],precip[i]))
except MySQLdb.Error, (errno, strerror):
print "(%s): %s" % (errno, strerror)
#self.db.commit()
def iIndMarit(self,today,codunid,altola):
rang = [7,13,19,25,31,37,43,49] #Rango de Hora x Dia Registrado
print "altola::",altola
r = 0
try:
for i in range(len(altola)): #vector de cobertura
for j in range(len(altola[i])):
fecha_ = deltadate(today,rang[r])
str_ = "INSERT INTO ind_marit_ng (fecha,unidad,nv_cost) VALUES (%s,%s,%s)"
print str_ % (fecha_,codunid,altola[i][j])
r+=1
#self.cur.execute(str_, (today,codunid,altola[i],rang[i]))
except MySQLdb.Error, (errno, strerror):
print "(%s): %s" % (errno, strerror)
#self.db.commit()
def updindcrs(self,samemnth,today,codunid,posll_d,posll_n,temp_d,temp_n,hum_d,hum_n,dirv_d,dirv_n,velv_d,velv_n):
try:
if samemnth:
str_ = "UPDATE indicrs SET posll_d=%s,posll_n=%s,temp_d=%s,temp_n=%s,hum_d=%s,hum_n=%s,dirv_d=%s,dirv_n=%s,velv_d=%s,velv_n=%s WHERE fecha=%s AND unidad=%s"
print str_ % (posll_d,posll_n,temp_d,temp_n,hum_d,hum_n,dirv_d,dirv_n,velv_d,velv_n,today,codunid)
#self.cur.execute(str_, (posll_d,posll_n,temp_d,temp_n,hum_d,hum_n,dirv_d,dirv_n,velv_d,velv_n,today,codunid))
else:
str_ = "INSERT INTO indicrs (fecha,unidad,posll_d,posll_n,temp_d,temp_n,hum_d,hum_n,dirv_d,dirv_n,velv_d,velv_n) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)"
print str_ % (today,codunid,posll_d,posll_n,temp_d,temp_n,hum_d,hum_n,dirv_d,dirv_n,velv_d,velv_n)
#self.cur.execute(str_, (today,codunid,posll_d,posll_n,temp_d,temp_n,hum_d,hum_n,dirv_d,dirv_n,velv_d,velv_n))
except MySQLdb.Error, (errno, strerror):
print "(%s): %s" % (errno, strerror)
#self.db.commit()
# try:
# self.cur.execute(str_, (monort,monoca,monmax,fecha,unit))
# print str_ % (monort,monoca,monmax,fecha,unit)
# except MySQLdb.Error, (errno, strerror):
# print "(%s): %s" % (errno, strerror)
# self.db.commit() #MariaDB requiere commit!!
return
def closecnx(self):
self.db.close()
if __name__ == '__main__':
#dbhost = ['dimarbtaweb19','copiapo'] #temporalmente deshabilitado
dbhost = ['copiapo']
for db in range(len(dbhost)):
cnxBD = pronarc_db(dbhost[db]) #Conexion a MariaDB
units = cnxBD.getunits() #fetch unidades
abrevs = getUAbrv(units); #fetch city,abrevs
opaere = cnxBD.getopaer() #fetch operaciones aereas
lstMnt = cnxBD.getlasmonth(); # Obtiene el ultimo mes registrado
#print opaere[2]['code']
#hoy = str(ANODEFA)+'-'+str(MESDEFA).zfill(2)+'-'+str(DIADEFA).zfill(2) #Fecha hoy obtenida del reloj
#print abrevs
if len(argv) > 1:
if argv[1] == '-type':
if argv[2] == 'm':
allmonth = sunM(cnxBD,units,abrevs) # Retorna una lista con todo el mes completo en formato YYYY-mm-dd
moonM(cnxBD,abrevs,allmonth)
elif argv[2] == 'd':
curMPh = cnxBD.getmoonph() #Extrae tabla con fases de la luna
#print curMPh, abrevs
moonD(cnxBD,curMPh,abrevs)
elif argv[2] == 'gfs': #Procesa conjunto de variables que proceden del GFS
fGFS = open('datapronarc_.dat')
gfsdata = getGFSparms(fGFS) #gfsdata[0] = vector/matrix, gfsdata[1] = fecha
fGFS.close()
print "GFS date is ",gfsdata[1]
#print gfsdata[0], units
sndGFSdat(cnxBD,units,gfsdata[0],gfsdata[1],opaere,lstMnt)
cnxBD.closecnx() #Cerrar conexion MariaDB
# else:
# #instancia METOC_DB
# res_ = cnxBD.getmoonph()
# print res_