def enviar_metadata_ut(par_Ruta_Arch):
from pathlib import Path
objUtileria = Utileria()
cnn = objUtileria.CrearConexionRDS()
cnn.autocommit = True
# Barremos los csv de Ejecuciones
for data_file in Path(par_Ruta_Arch).glob('*.csv'):
try:
objUtileria.InsertarEnRDSDesdeArchivo(cnn, data_file,
'linaje.unit_tests')
except Exception:
print('Excepcion en Metadata_Extract')
raise ('Excepción de prueba')
def __init__(self):
from Class_Utileria import Utileria
# Lo primero es: saber en qué ambiente se está trabajando
self.objUtileria = Utileria()
if self.objUtileria.ObtenerUsuario() == 'ec2-user':
self.str_Ambiente = 'EC2'
else:
self.str_Ambiente = 'Local'
# Cargamos los directorios de trabajo
self.str_DirDriver, self.str_DirDescargas = self.ObtenerDirectorios()
self.str_Url = 'https://www.transtats.bts.gov/DL_SelectFields.asp?Table_ID=236'
return
def generar_archivo_metadata_ut(par_UnitTest, par_Ruta):
from Class_ValueObjects import voUnitTest
obj_Utileria = Utileria()
conn = obj_Utileria.CrearConexionRDS()
nbr_Id_UnitTest = obj_Utileria.ObtenerMaxId(conn, 'linaje.unit_tests',
'id_unit_test') + 1
voEjecucion = voUnitTest()
voEjecucion.nbr_id_unittest = nbr_Id_UnitTest
voEjecucion.str_nombre_clase = par_UnitTest.__name__
voEjecucion.str_nombre_metodo = par_UnitTest.str_NombreMetodo
voEjecucion.str_estatus = par_UnitTest.str_Estatus
voEjecucion.str_mensaje = par_UnitTest.str_Mensaje
voEjecucion.dt_hora_ejec = par_UnitTest.dt_HoraEjec
voEjecucion.str_NombreDataFrame = par_Ruta + par_UnitTest.__name__ \
+ '_' + par_UnitTest.str_NombreMetodo \
+ '.csv'
voEjecucion.crearCSV()
def get(self):
fecha = request.args.get('fecha')
id_operador = request.args.get('id_operador')
id_avion = request.args.get('id_avion')
num_vuelo = request.args.get('num_vuelo')
origen = request.args.get('origen')
destino = request.args.get('destino')
horasalidaf = request.args.get('horasalidaf')
from Class_Utileria import Utileria
obj_Utileria = Utileria()
str_Query = "select * from trabajo.predicciones where fecha = '2016-01-02' and id_operador = 'WN' and id_avion='7819A' and num_vuelo='6308' and origen='MDW' and destino = 'PIT' and horasalidaf='545'"
str_Query = "select * from trabajo.predicciones where 1=1"
if fecha is not None:
str_Query = str_Query + " and fecha = '{}'".format(fecha)
if id_operador is not None:
str_Query = str_Query + " and id_operador = '{}'".format(
id_operador)
if id_avion is not None:
str_Query = str_Query + " and id_avion = '{}'".format(id_avion)
if num_vuelo is not None:
str_Query = str_Query + " and num_vuelo = '{}'".format(num_vuelo)
if origen is not None:
str_Query = str_Query + " and origen = '{}'".format(origen)
if destino is not None:
str_Query = str_Query + " and destino = '{}'".format(destino)
if horasalidaf is not None:
str_Query = str_Query + " and horasalidaf = '{}'".format(
horasalidaf)
str_Query = str_Query + ";"
try:
connection = Utileria().CrearConexionRDS()
cursor = connection.cursor()
cursor.execute(str_Query)
records = cursor.fetchall()
df = pd.DataFrame(records)
col_names = [i[0] for i in cursor.description]
df.columns = col_names
cursor.close()
connection.close()
except:
raise
return df.to_dict()
class Rita:
# Declaración de propiedades
str_Url = ''
str_Ambiente = ''
str_TipoEjecucion = 'Prueba'
# str_TipoEjecucion='Real'
# Campos para activar y desactivar
dict_Campos = {
'Year': {
'Id': 3,
'Flag': 'A'
},
'Month': {
'Id': 5,
'Flag': 'A'
},
'DayofMonth': {
'Id': 6,
'Flag': 'A'
},
'DayofWeek': {
'Id': 7,
'Flag': 'A'
},
'Reporting_Airline': {
'Id': 10,
'Flag': 'A'
},
'Tail_Number': {
'Id': 13,
'Flag': 'A'
},
'Flight_Number_Reporting_Airline': {
'Id': 14,
'Flag': 'A'
},
'OriginAirportID': {
'Id': 16,
'Flag': 'I'
},
'OriginAirportSeqID': {
'Id': 17,
'Flag': 'I'
},
'OriginCityMarketID': {
'Id': 18,
'Flag': 'I'
},
'Origin': {
'Id': 19,
'Flag': 'A'
},
'DestAirportID': {
'Id': 26,
'Flag': 'I'
},
'DestAirportSeqID': {
'Id': 27,
'Flag': 'I'
},
'DestCityMarketID': {
'Id': 28,
'Flag': 'I'
},
'Dest': {
'Id': 29,
'Flag': 'A'
},
'CRSDepTime': {
'Id': 36,
'Flag': 'A'
},
'DepTime': {
'Id': 37,
'Flag': 'A'
},
'DepDelayMinutes': {
'Id': 38,
'Flag': 'A'
},
'CRSArrTime': {
'Id': 48,
'Flag': 'A'
},
'CRSElapsedTime': {
'Id': 60,
'Flag': 'A'
},
'Distance': {
'Id': 64,
'Flag': 'A'
}
}
dict_Campos_Schedule = {
'Year': {
'Id': 3,
'Flag': 'A'
},
'Month': {
'Id': 5,
'Flag': 'A'
},
'DayofMonth': {
'Id': 6,
'Flag': 'A'
},
'DayofWeek': {
'Id': 7,
'Flag': 'A'
},
'Reporting_Airline': {
'Id': 10,
'Flag': 'A'
},
'Tail_Number': {
'Id': 13,
'Flag': 'A'
},
'Flight_Number_Reporting_Airline': {
'Id': 14,
'Flag': 'A'
},
'OriginAirportID': {
'Id': 16,
'Flag': 'I'
},
'OriginAirportSeqID': {
'Id': 17,
'Flag': 'I'
},
'OriginCityMarketID': {
'Id': 18,
'Flag': 'I'
},
'Origin': {
'Id': 19,
'Flag': 'A'
},
'DestAirportID': {
'Id': 26,
'Flag': 'I'
},
'DestAirportSeqID': {
'Id': 27,
'Flag': 'I'
},
'DestCityMarketID': {
'Id': 28,
'Flag': 'I'
},
'Dest': {
'Id': 29,
'Flag': 'A'
},
'CRSDepTime': {
'Id': 36,
'Flag': 'A'
},
'DepTime': {
'Id': 37,
'Flag': 'A'
},
'DepDelayMinutes': {
'Id': 38,
'Flag': 'A'
},
'CRSArrTime': {
'Id': 48,
'Flag': 'A'
},
'CRSElapsedTime': {
'Id': 60,
'Flag': 'A'
},
'Distance': {
'Id': 64,
'Flag': 'A'
}
}
# Listas con las estructuras de tablas para el linaje
lst_Ejecuciones = [("id_ejec", "NUMERIC"), ("usuario_ejec", "VARCHAR"),
("instancia_ejec", "VARCHAR"),
("fecha_hora_ejec", "TIMESTAMP"),
("bucket_s3", "VARCHAR"), ("tag_script", "VARCHAR"),
("tipo_ejec", "VARCHAR"),
("url_webscrapping", "VARCHAR"),
("status_ejec", "VARCHAR")]
lst_Archivos = [("id_ejec", "NUMERIC"), ("id_archivo", "VARCHAR"),
("num_registros", "VARCHAR"), ("num_columnas", "NUMERIC"),
("tamanio_archivo", "VARCHAR"), ("anio", "VARCHAR"),
("mes", "VARCHAR"), ("ruta_almac_s3", "VARCHAR")]
lst_ArchivosDet = [("id_archivo", "VARCHAR"), ("nombre_col", "VARCHAR")]
lst_Transform = [("id_set_transform", "NUMERIC"), ("num_seq", "NUMERIC"),
("nombre_query", "VARCHAR"),
("filas_afectadas", "VARCHAR "),
("fecha_hora_ejec", "TIMESTAMP"),
("usuario_ejec", "VARCHAR"),
("instancia_ejec", "VARCHAR"), ("tipo_ejec", "VARCHAR")]
lst_Modeling = [
("id_set_modelado", "NUMERIC"),
("nombre_modelo", "VARCHAR"),
#("hiperparametros", "JSON"),
("mejor_score_modelo", "NUMERIC"),
("fecha_hora_ejec", "TIMESTAMP"),
("usuario_ejec", "VARCHAR"),
("instancia_ejec", "VARCHAR")
]
lst_BiasFairness = [("atributo_protegido", "VARCHAR"),
("grupo_referencia", "VARCHAR"),
("fecha_hora_ejec", "TIMESTAMP"),
("usuario_ejec", "VARCHAR"),
("instancia_ejec", "VARCHAR")]
lst_Predicciones = [("fecha", "VARCHAR"), ("day_sem", "VARCHAR"),
("id_operador", "VARCHAR"), ("id_avion", "VARCHAR"),
("num_vuelo", "VARCHAR"), ("origen", "VARCHAR"),
("destino", "VARCHAR"), ("horasalidaf", "VARCHAR"),
("salida_realf", "VARCHAR"),
("tiempo_trans_vuelo", "VARCHAR"),
("distancia_millas", "VARCHAR"),
("hora_llegada_progf", "VARCHAR"),
("delay2", "VARCHAR"), ("bandera_delay", "VARCHAR"),
("count", "VARCHAR"), ("max", "VARCHAR"),
("nvue_falt", "VARCHAR"), ("ind_retraso1", "VARCHAR"),
("ind_retraso2", "VARCHAR"),
("ind_retraso3", "VARCHAR"), ("efecto", "VARCHAR"),
("sum_efectos_domino", "VARCHAR"),
("tot_sum_domino", "VARCHAR"),
("vuelos_afectados", "VARCHAR"), ("year", "VARCHAR"),
("y_hat", "VARCHAR")]
st_Predicciones = [("id_ejec", "VARCHAR"), ("id_archivo", "VARCHAR"),
("num_registros", "VARCHAR"),
("num_columnas", "VARCHAR")]
# Directorios
str_DirDriver = ''
str_DirDescargas = ''
str_ArchivoDescargado = ''
str_MasReciente = ''
# Declaración de métodos
def __init__(self):
from Class_Utileria import Utileria
# Lo primero es: saber en qué ambiente se está trabajando
self.objUtileria = Utileria()
if self.objUtileria.ObtenerUsuario() == 'ec2-user':
self.str_Ambiente = 'EC2'
else:
self.str_Ambiente = 'Local'
# Cargamos los directorios de trabajo
self.str_DirDriver, self.str_DirDescargas = self.ObtenerDirectorios()
self.str_Url = 'https://www.transtats.bts.gov/DL_SelectFields.asp?Table_ID=236'
return
def DescargarAnioMes(self, nbr_Anio, str_Mes):
# Creacion del driver y conexion a la Url
driver = self.CrearDriverChrome(self.str_DirDriver,
self.str_DirDescargas)
driver.command_executor._commands["send_command"] = (
"POST", '/session/$sessionId/chromium/send_command')
params = {
'cmd': 'Page.setDownloadBehavior',
'params': {
'behavior': 'allow',
'downloadPath': self.str_DirDescargas
}
}
command_result = driver.execute("send_command", params)
print('Esperando a la pagina...', self.str_Url)
driver.get(self.str_Url)
# Bajamos el anio y mes indicados
driver.find_element_by_xpath("//select[@name='XYEAR']/option[text()=" +
str(nbr_Anio) + "]").click()
driver.find_element_by_xpath(
"//select[@name='FREQUENCY']/option[text()='" + str(str_Mes) +
"']").click()
# Seleccionamos los campos deseados para crear la base de datos
print('Seleccionando campos para descarga...')
for campo in self.dict_Campos.items():
xpath_finales = "/html/body/div[3]/div[3]/table[1]/tbody/tr/td[2]/table[4]/tbody/tr[%d]/td[1]/input[@type=\'checkbox\']" % campo[
1]['Id']
element = driver.find_element_by_xpath(xpath_finales)
driver.execute_script("arguments[0].click();", element)
# Método 1
# driver.find_element_by_xpath(xpath_finales).click()
# Método 2
# wait = WebDriverWait(driver, 30)
# element = wait.until(EC.element_to_be_clickable((By.XPATH, xpath_finales)))
# element.click()
nbr_Aleat = np.random.uniform(1, 2, 1)
time.sleep(nbr_Aleat)
# Bajamos el archivo
print('Generando archivo...')
driver.execute_script('tryDownload()')
str_ext = ''
# Este while es para esperar a que termine la descarga completa del archivo en turno
print('Bajando el archivo...')
while str_ext != '.zip':
print(datetime.datetime.now())
list_file = glob.glob(
self.str_DirDescargas +
'/*.zip') # * means all if need specific format then *.csv
if len(list_file) != 0:
str_file = list_file[0]
arr_aux = os.path.splitext(str_file)
str_name = arr_aux[0]
str_ext = arr_aux[1]
time.sleep(1)
# Guardamos en la clase el nombre del archivo
self.str_ArchivoDescargado = str_name
# Cerramos el driver junto con el browser
driver.quit()
return 0
def CrearDriverChrome(self, str_DirDriver, str_DirDescargas):
# Preparamos el directorio correspondiente
PROJECT_ROOT = os.path.abspath(os.path.dirname(str_DirDriver))
DRIVER_BIN = os.path.join(PROJECT_ROOT, "chromedriver")
# ### Config Chrome
chrome_options = webdriver.ChromeOptions()
prefs = {
'download.default_directory': str_DirDescargas,
'download.prompt_for_download': False,
'download.directory_upgrade': True,
'safebrowsing_for_trusted_sources_enabled': False,
'safebrowding.enabled': False,
'profile.default_content_setting_values.automatic_downloads': 1,
'profile.default_content_settings.popups': 0
}
chrome_options.add_experimental_option("prefs", prefs)
chrome_options.add_argument('--headless')
chrome_options.add_argument('--no-sandbox')
return webdriver.Chrome(executable_path=DRIVER_BIN,
options=chrome_options)
def ObtenerAnios(self):
if self.str_TipoEjecucion == 'Prueba':
self.arr_Anios = [2016]
else:
self.arr_Anios = [2016, 2017, 2018, 2019]
return self.arr_Anios
def ObtenerMeses(self):
if self.str_TipoEjecucion == 'Prueba':
self.arr_Meses = ['January', 'February']
else:
self.arr_Meses = [
'January', 'February', 'March', 'April', 'May', 'June', 'July',
'August', 'September', 'October', 'November', 'December'
]
return self.arr_Meses
def Modelar(self, str_ArchivoDataSet):
from Class_Eda import Eda
from Class_ValueObjects import voModeling
from datetime import datetime
#objUtileria = Utileria()
voModeling = voModeling()
# Instanciamos el objeto Eda
objEda = Eda()
# Inicializamos los parámetros principales (por el momento, sólo es uno: la ruta de la fuente de datos)
objEda.strRutaDataSource = str_ArchivoDataSet
# Especificamos nuestro separador de columnas y cargamos el dataset
objEda.strSeparadorColumnas = ','
objEda.Cargar_Datos()
# Temporalmente se trabaja con una porción de los datos
filas = objEda.pdDataSet.shape[0]
porcion = int(filas / 10)
objEda.pdDataSet = objEda.pdDataSet.drop(
objEda.pdDataSet.index[porcion:filas])
# filas = objEda.pdDataSet.shape[0]
# Proceso de limpieza
objEda.Limpiar_Datos()
# Guardamos el arreglo en la nueva columna
objEda.pdDataSet['y'] = objEda.pdDataSet.apply(lambda x: (x.etiqueta1),
axis=1)
# Eliminamos las columnas
objEda.pdDataSet = objEda.pdDataSet.drop(['fecha'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['id_operador'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['salida_realf'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['bandera_delay'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['ind_retraso2'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['ind_retraso3'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['sum_efectos_domino'],
axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['tot_sum_domino'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['tiempo_trans_vuelo'],
axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['distancia_millas'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['delay2'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['ind_retraso1'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['efecto'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['year'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['etiqueta1'], axis=1)
# Variables a incluir que se eliminan en esta prueba:
objEda.pdDataSet = objEda.pdDataSet.drop(['horasalidaf'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['hora_llegada_progf'],
axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['num_vuelo'], axis=1)
objEda.pdDataSet = objEda.pdDataSet.drop(['id_avion'], axis=1)
# Hacemos el label encoder para cada columna por separado
# Esto es para que no se incremente tanto el número de columnas
# del dataset de golpe y así evitar problemas de memoria
objEda.npLabelEncoderFeat = np.array([])
objEda.Agregar_Features_LabelEnc('day_sem')
objEda.Agregar_Features_LabelEnc('origen')
objEda.Agregar_Features_LabelEnc('destino')
objEda.LabelEncoder_OneHotEncoder()
objEda.Borrar_Cols_Base_LabelEnc()
objEda.Borrar_Cols_Inter_LabelEnc()
# Separamos las features de lo que vamos a predecir
pdX, pdY = objEda.SepararFeaturesYPred('y')
# Separamos nuestros datos en entrenamiento y pruebas utilizando la proporción 80-20
objEda.Generar_Train_Test(pdX, pdY, 0.2)
# Preparamos las variables que imputaremos
objEda.listTransform = [
''
] # Limpiamos la propiedad de lista de features a imputar
objEda.Agregar_Features_Transform(
'median', 'vuelos_afectados') # no hizo nada porque están como NaN
# Imputamos sobre el conjunto de entrenamiento y prueba
objEda.X_train = objEda.Imputar_Features(objEda.X_train)
objEda.X_test = objEda.Imputar_Features(objEda.X_test)
# Se crean los hyperparámetros con los que se trabajará
# Arreglo de diccionarios por modelo (deben ir en el órden a ejecutar)
npDictHiperParam = np.array([])
# Parametrización para Árboles
dictHyperParams = {
'max_depth': [4], # [4,7]
'min_samples_split': [4], # [4,16]
'min_samples_leaf': [3], # [3,7]
'max_features': ['sqrt'] # ['sqrt','log2']
}
npDictHiperParam = np.append(npDictHiperParam, dictHyperParams)
# Parametrización para Bosques
dictHyperParams = {
'n_estimators': [25], # Se redujo a 50
'max_depth': [4], # [4,7]
'max_features': ['sqrt'], # ['sqrt','log2']
'min_samples_split': [4], # [4,16]
'min_samples_leaf': [3] # [3,7]
}
npDictHiperParam = np.append(npDictHiperParam, dictHyperParams)
# Parametrización para XGBoost
dictHyperParams = {
'learning_rate': [0.25, 0.75],
'n_estimators': [25], # Se redujo a 50
'min_samples_split': [4], # [4,16]
'min_samples_leaf': [3], # [3,7]
'max_depth': [5], # [4,7]
'max_features': ['sqrt']
}
npDictHiperParam = np.append(npDictHiperParam, dictHyperParams)
# Se crean los modelos de clasificaión que se emplearán (en el mismo orden que los diccionarios)
npNombreModelos = np.array([])
npNombreModelos = np.append(npNombreModelos, 'DECTREE')
npNombreModelos = np.append(npNombreModelos, 'RANDOMF')
npNombreModelos = np.append(npNombreModelos, 'XGBOOST')
arrModelos = objEda.prepModelos(npNombreModelos)
# #Se corre el magic loop para realizar las predicciones con los parámetros previamente establecidos
npGridSearchCv = objEda.Correr_Magic_Loop(arrModelos, npDictHiperParam,
objEda.X_train,
objEda.Y_train, 5)
npArrBestScores = np.array([])
npArrBestParams = np.array([])
# Barremos el arreglo de GridSearchCV´s para sacar los mejores scores y parámetros
for grid in npGridSearchCv:
npArrBestScores = np.append(npArrBestScores, grid.best_score_)
npArrBestParams = np.append(npArrBestParams, grid.best_params_)
# Obtenemos el índice del mejor score
nbrIndiceGanador = np.argmax(npArrBestScores, axis=0)
# Mostramos el modelo, parámetros y score ganador
# print("Modelo ganador: \n", arrModelos[nbrIndiceGanador])
# print("Score del modelo ganador: \n", npArrBestScores[nbrIndiceGanador])
# print("Parametros del modelo ganador: \n", npArrBestParams[nbrIndiceGanador])
# Se instancia el modelo ganador
# self.ModeloGanadorMagicLoop = objEda.InstanciarModeloDinamico(npNombreModelos, nbrIndiceGanador, npArrBestParams[nbrIndiceGanador])
self.ModeloGanadorMagicLoop = objEda.best_model
conn = self.objUtileria.CrearConexionRDS()
nbr_id_set_modelado = self.objUtileria.ObtenerMaxId(
conn, 'linaje.modeling', 'id_set_modelado') + 1
for grid in npGridSearchCv:
voModeling.nbr_id_set_modelado = nbr_id_set_modelado
voModeling.str_nombre_modelo = str(type(grid.estimator))
# voModeling.dict_hiperparametros = str(grid.param_grid)
voModeling.nbr_mejor_score_modelo = grid.best_score_
voModeling.str_NombreDataFrame = 'Linaje/Modeling/' \
+ voModeling.str_nombre_modelo \
+ '.csv'
voModeling.dttm_fecha_hora_ejec = datetime.now()
voModeling.str_usuario_ejec = self.objUtileria.ObtenerUsuario()
voModeling.str_instancia_ejec = self.objUtileria.ObtenerIp()
# Creamos el CSV que contiene el linaje de esta información
voModeling.crearCSV()
# Almacenamos el objeto Eda en la clase para usarlo afuera
self.ObjEda = objEda
def ObtenerDirectorios(self):
if self.str_Ambiente == 'Local':
self.str_DirDriver = '/Users/Marco/github/dpa_equipo2/Scripts/chromedriver.exe'
self.str_DirDescargas = '/Users/Marco/github/dpa_equipo2/Scripts/Descargas'
elif self.str_Ambiente == 'EC2':
self.str_DirDriver = '/home/ec2-user/dpa_equipo2/Scripts/chromedriver.exe'
self.str_DirDescargas = '/home/ec2-user/dpa_equipo2/Scripts/Descargas'
return self.str_DirDriver, self.str_DirDescargas
def ObtenerDirectorioTrabajo(self):
if self.str_Ambiente == 'Local':
self.str_DirTrabajo = '/Users/Marco/github/dpa_equipo2/Scripts'
elif self.str_Ambiente == 'EC2':
self.str_DirTrabajo = '/home/ec2-user/dpa_equipo2/Scripts'
return self.str_DirTrabajo
def ObtenerMesDescargaRecurrente(self):
# Creacion del driver y conexion a la Url
driver = self.CrearDriverChrome(self.str_DirDriver,
self.str_DirDescargas)
driver.command_executor._commands["send_command"] = (
"POST", '/session/$sessionId/chromium/send_command')
params = {
'cmd': 'Page.setDownloadBehavior',
'params': {
'behavior': 'allow',
'downloadPath': self.str_DirDescargas
}
}
command_result = driver.execute("send_command", params)
driver.get(self.str_Url)
#Buscamos el mes y anio más reciente disponible en la página
latest_field = driver.find_element_by_xpath(
"//table[1]/tbody/tr/td[2]/table[2]/tbody/tr[3]/td[1]")
self.str_MasReciente = latest_field.text.replace(
"Latest Available Data: ", "") #Removemos el texto fijo
#Cerramos el driver junto con el browser
driver.quit()
return self.str_MasReciente
def DescargarAnioMesSchedules(self, nbr_Anio, str_Mes):
# Creacion del driver y conexion a la Url
driver = self.CrearDriverChrome(self.str_DirDriver,
self.str_DirDescargas)
driver.command_executor._commands["send_command"] = (
"POST", '/session/$sessionId/chromium/send_command')
params = {
'cmd': 'Page.setDownloadBehavior',
'params': {
'behavior': 'allow',
'downloadPath': self.str_DirDescargas
}
}
command_result = driver.execute("send_command", params)
print('Esperando a la pagina...', self.str_Url)
driver.get(self.str_Url)
# Bajamos el anio y mes indicados
driver.find_element_by_xpath("//select[@name='XYEAR']/option[text()=" +
str(nbr_Anio) + "]").click()
driver.find_element_by_xpath(
"//select[@name='FREQUENCY']/option[text()='" + str(str_Mes) +
"']").click()
# Seleccionamos los campos deseados para crear la base de datos
print('Seleccionando campos para descarga...')
for campo in self.dict_Campos_Schedule.items():
xpath_finales = "/html/body/div[3]/div[3]/table[1]/tbody/tr/td[2]/table[4]/tbody/tr[%d]/td[1]/input[@type=\'checkbox\']" % campo[
1]['Id']
element = driver.find_element_by_xpath(xpath_finales)
driver.execute_script("arguments[0].click();", element)
# Método 1
# driver.find_element_by_xpath(xpath_finales).click()
# Método 2
# wait = WebDriverWait(driver, 30)
# element = wait.until(EC.element_to_be_clickable((By.XPATH, xpath_finales)))
# element.click()
nbr_Aleat = np.random.uniform(1, 2, 1)
time.sleep(nbr_Aleat)
# Bajamos el archivo
print('Generando archivo...')
driver.execute_script('tryDownload()')
str_ext = ''
# Este while es para esperar a que termine la descarga completa del archivo en turno
print('Bajando el archivo...')
while str_ext != '.zip':
print(datetime.datetime.now())
list_file = glob.glob(
self.str_DirDescargas +
'/*.zip') # * means all if need specific format then *.csv
if len(list_file) != 0:
str_file = list_file[0]
arr_aux = os.path.splitext(str_file)
str_name = arr_aux[0]
str_ext = arr_aux[1]
time.sleep(1)
# Guardamos en la clase el nombre del archivo
self.str_ArchivoDescargado = str_name
# Cerramos el driver junto con el browser
driver.quit()
return 0
class TestLoad(marbles.core.TestCase):
from Class_Utileria import Utileria
from Class_Rita import Rita
objRita = Rita()
objUtileria = Utileria()
# Variables para metadata
str_NombreMetodo = ''
str_Estatus = ''
str_Mensaje = ''
dt_HoraEjec = None
str_NombreArchivo = ''
# Variable reservada
__name__ = 'TestLoad'
def test_load_count_columns(self):
# Contar número de columnas de cada csv en S3
__s3 = boto3.client('s3')
__str_note = 'numero de columnas en el archivo csv no es el esperado'
__arr_Anios = self.objRita.ObtenerAnios()
__arr_Meses = self.objRita.ObtenerMeses()
for anio in __arr_Anios:
for mes in __arr_Meses:
__aniio = str(anio)
__mess = str(mes)
print(__aniio)
print(__mess)
__conn = self.objUtileria.CrearConexionRDS()
__query = "select id_archivo from linaje.archivos where anio='" + __aniio + "' and mes='" + __mess + "';"
__cur = __conn.cursor()
__cur.execute(__query)
__nombre_archivo = __cur.fetchone()[0]
print(__nombre_archivo)
__str_directorio = 'carga_inicial/' + str(anio) + '/' + str(
mes) + '/' + __nombre_archivo
__obj = __s3.get_object(
Bucket=self.objUtileria.str_NombreBucket,
Key=__str_directorio)
__df = pd.read_csv(io.BytesIO(__obj['Body'].read()))
__df.drop(__df.filter(regex="Unname"), axis=1, inplace=True)
__num_columns = len(__df.columns)
self.str_NombreMetodo = 'test_load_count_columns'
self.dt_HoraEjec = datetime.now()
try:
self.assertEqual(__num_columns, 15, note=__str_note)
self.str_Estatus = 'OK'
except BaseException as errorPrueba:
self.str_Estatus = 'FAILED'
self.str_Mensaje = errorPrueba
break
class TestPredict(marbles.core.TestCase):
from Class_Utileria import Utileria
objUtileria = Utileria()
# Variables para metadata
str_NombreMetodo = ''
str_Estatus = ''
str_Mensaje = ''
dt_HoraEjec = None
str_NombreArchivo = ''
# Variable reservada
__name__ = 'TestPredict'
def test_predict_delay_binary(self):
s = "SELECT *"
s += " FROM "
s += "trabajo.predicciones"
# Nos conectamos con la RDS.
__conn = self.objUtileria.CrearConexionRDS()
__cur = __conn.cursor()
# Use the COPY function on the SQL we created above.
SQL_for_file_output = "COPY ({0}) TO STDOUT WITH CSV HEADER;".format(s)
# Set up a variable to store our file path and name.
t_path_n_file = "/home/ec2-user/dpa_equipo2/Scripts/Predict.csv"
with open(t_path_n_file, 'w') as f_output:
__cur.copy_expert(SQL_for_file_output, f_output)
__str_RutaScripts = os.path.abspath(os.path.curdir)
__df = pd.read_csv(__str_RutaScripts + '/Predict.csv')
__m = __df['y_hat'].isin([0,1]).all()
__str_note = 'existen valores distintos de 0 y 1'
self.str_NombreMetodo = 'test_predict_delay_binary'
self.dt_HoraEjec = datetime.now()
try:
self.assertTrue(__m, note=__str_note)
self.str_Estatus = 'OK'
except BaseException as errorPrueba:
self.str_Estatus = 'FAILED'
self.str_Mensaje = errorPrueba
def test_predict_df_compare(self):
__str_RutaScripts = os.path.abspath(os.path.curdir)
__df1 = pd.read_csv(__str_RutaScripts + '/Predict.csv')
__df2 = pd.read_csv(__str_RutaScripts + '/DatasetModelado.csv')
__m = __df1.shape[0]==__df2.shape[0]
__str_note = 'los df no tiene el mismo numero de renglones'
self.str_NombreMetodo = 'test_predict_df_compare'
self.dt_HoraEjec = datetime.now()
try:
self.assertTrue(__m, note=__str_note)
self.str_Estatus = 'OK'
except BaseException as errorPrueba:
self.str_Estatus = 'FAILED'
self.str_Mensaje = errorPrueba