def DataDistributionByDate(catalog, tabla, row, dia_fecha):
contiene_fecha = map.get(tabla, dia_fecha, greater)
if contiene_fecha == None:
datos = {"estados_accidentados": {}, "estado_mas_accidentado": None, "num_accidentes_estado_mas_accidentado": 0}
# 4 Severidades posibles
datos[1] = {"size":0, "data": hashmap.newMap(1613, maptype='CHAINING'), "num_accidentes_ciudad_mas_accidentada": 0, "ciudad_mas_accidentada": None, "num_ciudades_accidentadas": 0, "ciudades_accidentadas":[]}
datos[2] = {"size":0, "data": hashmap.newMap(1613, maptype='CHAINING'), "num_accidentes_ciudad_mas_accidentada": 0, "ciudad_mas_accidentada": None, "num_ciudades_accidentadas": 0, "ciudades_accidentadas":[]}
datos[3] = {"size":0, "data": hashmap.newMap(1613, maptype='CHAINING'), "num_accidentes_ciudad_mas_accidentada": 0, "ciudad_mas_accidentada": None, "num_ciudades_accidentadas": 0, "ciudades_accidentadas":[]}
datos[4] = {"size":0, "data": hashmap.newMap(1613, maptype='CHAINING'), "num_accidentes_ciudad_mas_accidentada": 0, "ciudad_mas_accidentada": None, "num_ciudades_accidentadas": 0, "ciudades_accidentadas":[]}
if datos["estados_accidentados"].get(row["State"]) == None:
datos["estados_accidentados"][row["State"]] = 1
else:
datos["estados_accidentados"][row["State"]] += 1
if datos["estados_accidentados"][row["State"]] > datos["num_accidentes_estado_mas_accidentado"]:
datos["num_accidentes_estado_mas_accidentado"] = datos["estados_accidentados"][row["State"]]
datos["estado_mas_accidentado"] = row["State"]
catalog["accidentsByDate"] = map.put(catalog["accidentsByDate"], dia_fecha, {"size":0,"data":datos}, greater)
contiene_fecha = map.get(catalog["accidentsByDate"], dia_fecha, greater)
contiene_fecha["size"] += 1
contiene_fecha["data"][int(row["Severity"])]["size"] += 1
contiene_ciudad = hashmap.get(contiene_fecha["data"][int(row["Severity"])]["data"], row["City"], compareByKey)
if contiene_ciudad == None:
datos = {"nombre":row["City"], "accidentes":0}
hashmap.put(contiene_fecha["data"][int(row["Severity"])]["data"], row["City"], datos, compareByKey)
contiene_ciudad = hashmap.get(contiene_fecha["data"][int(row["Severity"])]["data"], row["City"], compareByKey)
contiene_fecha["data"][int(row["Severity"])]["num_ciudades_accidentadas"] += 1
contiene_fecha["data"][int(row["Severity"])]["ciudades_accidentadas"].append(row["City"])
contiene_ciudad["value"]["accidentes"] += 1
if contiene_ciudad["value"]["accidentes"] > contiene_fecha["data"][int(row["Severity"])]["num_accidentes_ciudad_mas_accidentada"]:
contiene_fecha["data"][int(row["Severity"])]["num_accidentes_ciudad_mas_accidentada"] = contiene_ciudad["value"]["accidentes"]
contiene_fecha["data"][int(row["Severity"])]["ciudad_mas_accidentada"] = contiene_ciudad["value"]["nombre"]
def addYearTree(catalog, row):
"""
Adiciona el libro al arbol anual key=original_publication_year
"""
yearText = row['Start_Time']
if row['Start_Time']:
yearText = row['Start_Time'][0:row['Start_Time'].index(' ')]
year = strToDate(yearText, '%Y-%m-%d')
yearNode = tree.get(catalog['yearsTree'], year, greater)
if yearNode:
yearNode['count'] += 1
sev = int(row['Severity'])
yearNode['severity'][sev] += 1
city = row['City']
ratingCount = map.get(yearNode['ratingMap'], city, compareByKey)
if ratingCount:
ratingCount['Accidentes'] += 1
else:
ciudad = {'Ciudad': row['City'], 'Accidentes': 1}
map.put(yearNode['ratingMap'], ciudad['Ciudad'], ciudad,
compareByKey)
state = row['State']
state_count = tree.get(yearNode['state'], state, greater)
if state_count:
state_count['Accidentes'] += 1
else:
estado = {'Estado': row['State'], 'Accidentes': 1}
tree.put(yearNode['state'], estado['Estado'], estado, greater)
else:
yearNode = newYear(year, row)
catalog['yearsTree'] = tree.put(catalog['yearsTree'], year, yearNode,
greater)
def DaterankAccidentMap(catalog, fecha1, fecha2):
"""
Retorna un diccionario con la cantidad de accidentes en el rango de fechas (desde fecha #1 a fecha #2) y con el número de accidentes por ciudad en ese intervalo.
"""
info = {}
accidentes_totales = 0
ciudades = {}
for fecha in range(fecha1, fecha2 + 1):
for severidad in range(1, 5):
accidentes = map.get(catalog["accidentsByDate"], fecha, greater)
if accidentes != None:
accidentes_totales += accidentes["size"]
ciudades_totales = accidentes["data"][severidad]["data"]
if ciudades_totales != None:
llaves_ciudades = accidentes["data"][severidad]["ciudades_accidentadas"]
for llave in llaves_ciudades:
if ciudades.get(llave) == None:
get = hashmap.get(ciudades_totales, llave, compareByKey)
ciudades[llave] = get["value"]["accidentes"]
else:
get = hashmap.get(ciudades_totales, llave, compareByKey)
ciudades[llave] += get["value"]["accidentes"]
info["accidentes_totales"] = accidentes_totales
info["ciudades"] = ciudades
return info
def getBookByYearRating (catalog, year,Severity ):
"""
Retorna la cantidad de libros para un año y con un rating dado
"""
yearElement=tree.get(catalog['yearsTree'], strToDate(year,'%Y-%m-%d'), greater)
response=''
if yearElement:
response= map.get(yearElement['ratingMap'], Severity, compareByKey)
return response
return None
def Accidentes_estado_fecha(catalog, fecha):
fecha = strToDate(fecha, '%Y-%m-%d')
arbol_fecha = tree.get(catalog['yearsTree'], fecha, greater)
estados = tree.valueSet(arbol_fecha['state'])
for i in range(1, lt.size(estados) + 1):
respuesta = {'Estado': None, 'Accidentes': 0}
est = lt.getElement(estados, i)
if respuesta['Accidentes'] < est['Accidentes']:
respuesta = est
return respuesta
def getBookByYearRating(catalog, year):
"""
Retorna la cantidad de libros por rating para un año
"""
año = strToDate(year, '%Y-%m-%d')
yearNode = tree.get(catalog['yearsTree'], año, greater)
if yearNode:
sev = yearNode['severity']
sev['total'] = sev[1] + sev[2] + sev[3] + sev[4]
return sev
else:
return None
def getSeverityByDate(catalog, date):
Año = tree.get(catalog["AccidentsTree"], date, greater)
res = ""
if Año:
Severidades = map.keySet(Año["Severity"])
iterator = it.newIterator(Severidades)
res += "El total de accidentes la fecha " + str(date) + " fue " + str(
lt.size(Año["id"])) + "\n"
while it.hasNext(iterator):
SevKey = it.next(iterator)
res += 'Severidad ' + str(SevKey) + ' : ' + str(
map.get(Año["Severity"], SevKey, compareByKey)) + '\n'
return res
return None
def getBookByYearRating (catalog, year):
"""
Retorna la cantidad de libros para un año y con un rating dado
"""
yearElement=tree.get(catalog['yearsTree'], strToDate(year,'%Y'), greater)
response=''
if yearElement:
ratingList = map.keySet(yearElement['ratingMap'])
iteraRating=it.newIterator(ratingList)
while it.hasNext(iteraRating):
ratingKey = it.next(iteraRating)
response += 'Rating '+str(ratingKey) + ':' + str(map.get(yearElement['ratingMap'],ratingKey,compareByKey)) + '\n'
return response
return None
def getAccidentByDateSeverity (catalog, date):
"""
Retorna la cantidad de libros para un año y con un rating dado
"""
dateElement = tree.get(catalog['dateTree'], strToDate(date,'%Y-%m-%d') , greater)
response=''
if dateElement:
ratingList = map.keySet(dateElement['severityMap'])
iteraRating=it.newIterator(ratingList)
while it.hasNext(iteraRating):
ratingKey = it.next(iteraRating)
response += ''+str(ratingKey) + ':' + str(map.get(dateElement['severityMap'],ratingKey,compareByKey)) + '\n'
return response
return None
def addDateTree (catalog, row):
"""
Adiciona el libro al arbol anual key=original_publication_year
"""
DateText= row['Start_Time']
DateText = DateText[0:10]
date = strToDate(DateText,'%Y-%m-%d')
dateNode = tree.get(catalog['dateTree'], date, greater)
if dateNode:
city = row['City']
CityCount = map.get(dateNode['cityMap'], city, compareByKey)
if CityCount:
CityCount+=1
map.put(dateNode['cityMap'], city, CityCount, compareByKey)
else:
map.put(dateNode['cityMap'], city, 1, compareByKey)
else:
dateNode = newDate(date,row)
tree.put(catalog['dateTree'],date,dateNode,greater)
def addYearTree (catalog, row):
"""
Adiciona el libro al arbol anual key=original_publication_year
"""
yearText= row['original_publication_year']
if row['original_publication_year']:
yearText=row['original_publication_year'][0:row['original_publication_year'].index('.')]
year = strToDate(yearText,'%Y')
yearNode = tree.get(catalog['yearsTree'] , year, greater)
if yearNode:
intRating = round(float(row['average_rating']))
ratingCount = map.get(yearNode['ratingMap'], intRating, compareByKey)
if ratingCount:
ratingCount+=1
map.put(yearNode['ratingMap'], intRating, ratingCount, compareByKey)
else:
map.put(yearNode['ratingMap'], intRating, 1, compareByKey)
else:
yearNode = newYear(year,row)
catalog['yearsTree'] = tree.put(catalog['yearsTree'] , year, yearNode, greater)
def test_BSTRemove(self):
"""
"""
tree = bst.newMap('BST')
self.assertTrue(bst.isEmpty(tree))
bst.put(tree, '50', 'Title 50', self.comparekeys)
bst.put(tree, '70', 'Title 70', self.comparekeys)
bst.put(tree, '30', 'Title 30', self.comparekeys)
bst.put(tree, '80', 'Title 80', self.comparekeys)
bst.put(tree, '60', 'Title 60', self.comparekeys)
bst.put(tree, '40', 'Title 40', self.comparekeys)
bst.put(tree, '20', 'Title 20', self.comparekeys)
bst.put(tree, '10', 'Title 10', self.comparekeys)
bst.put(tree, '25', 'Title 6', self.comparekeys)
bst.put(tree, '6', 'Title 3', self.comparekeys)
bst.put(tree, '12', 'Title 12', self.comparekeys)
bst.put(tree, '7', 'Title 7', self.comparekeys)
bst.put(tree, '28', 'Title 28', self.comparekeys)
bst.remove(tree, '20', self.comparekeys)
self.assertIsNone(bst.get(tree, '20', self.comparekeys))
def addYearTree (catalog, row):
"""
Adiciona el libro al arbol anual key=original_publication_year
"""
yearText= row['Start_Time']
if row['Start_Time']:
yearText=row['Start_Time']
yearText.split(' ')
yearText= yearText[0]
year = strToDate(yearText,'%Y-%m-%d')
yearNode = tree.get(catalog['yearsTree'] , year, greater)
if yearNode:
intRating = round(float(row['Severity']))
ratingCount = map.get(yearNode['ratingMap'], intRating, compareByKey)
if ratingCount:
ratingCount+=1
map.put(yearNode['ratingMap'], intRating, ratingCount, compareByKey)
else:
map.put(yearNode['ratingMap'], intRating, 1, compareByKey)
else:
yearNode = newYear(year,row)
catalog['yearsTree'] = tree.put(catalog['yearsTree'] , year, yearNode, greater)
def Add_map_tree(catalogo, row):
city_zipc = row['zip_code']
lista_zip = city_zipc.split()
city = lista_zip[2]
city += lista_zip[3]
formato = '%m/%d/%Y'
fecha = strToDate(row['start_date'], formato)
ciudad_arbol = map.get(catlog['map_city_req2'], city)
if ciudad_arbol:
arbol = tree.get(ciudad_arbol, fecha, compareByKey)
if arbol:
arbol['viajes'] += 1
else:
dic = {'date': fecha, 'viajes': 1}
tree.put(ciudad_arbol, dic['date'], dic, compareByKey)
else:
value = tree.newMap()
dic = {'date': fecha, 'viajes': 1}
tree.put(value, dic['date'], dic, compareByKey)
map.put(catalog['map_city_req2'], city, value)
def addDateTree(catalog, row):
"""
Adiciona el accidente al arbol por día key=Start_Time
"""
dateText = row['Start_Time']
if row['Start_Time']:
dateText = row['Start_Time'][0:row['Start_Time'].index(' ')]
date = strToDate(dateText, '%Y-%m-%d')
dateNode = tree.get(catalog['dateTree'], date, greater)
if dateNode:
severity = int(row['Severity'])
accidentCount = map.get(dateNode['severityMap'], severity,
compareByKey)
if accidentCount:
accidentCount += 1
map.put(dateNode['severityMap'], severity, accidentCount,
compareByKey)
else:
map.put(dateNode['severityMap'], severity, 1, compareByKey)
else:
dateNode = newDate(date, row)
catalog['dateTree'] = tree.put(catalog['dateTree'], date, dateNode,
greater)
def addAccidentDate(catalog, row):
"""
Adiciona libro al map con key=title
"""
#catalog['booksTree'] = map.put(catalog['booksTree'], int(book['book_id']), book, greater)
Accidents = catalog['AccidentsTree']
Exist = tree.get(Accidents, row["Start_Time"].split(" ")[0], greater)
if Exist:
lt.addLast(Exist['id'], row['ID'])
Contador = row["Severity"]
Nuevovalor = map.get(Exist["Severity"], Contador, compareByKey)
if Nuevovalor:
Nuevovalor += 1
map.put(Exist["Severity"], Contador, Nuevovalor, compareByKey)
else:
map.put(Exist["Severity"], Contador, 1, compareByKey)
tree.put(catalog['AccidentsTree'], row["Start_Time"].split(" ")[0],
Exist, greater)
#director['sum_average_rating'] += float(row['vote_average'])
else:
Accident = newAccidentDate(catalog, row)
catalog['AccidentsTree'] = tree.put(Accidents, Accident["Date"],
Accident, greater)
def main():
datos_cargados = False
while True:
printMenu()
inputs =input('Seleccione una opción para continuar\n')
if int(inputs[0])==1: # 1- Cargar información
if not datos_cargados:
print("Cargando información de los archivos ....")
print("Recursion Limit:",sys.getrecursionlimit())
catalog = initCatalog ()
loadData (catalog)
"""
print ('Arbol Libros cargados: ' + str(map.size(catalog['booksTree'])))
print ('Lista libros cargados: ' + str(lt.size(catalog['booksList'])))
print ('Altura arbol: ' + str(map.height(catalog['booksTree'])))
"""
print ('Arbol Accidentes cargados: ' + str(map.size(catalog['accidentsTree'])))
print ('Hash Accidentes cargados: ' + str(hashmap.size(catalog['accidentsHash'])))
print ('Lista Accidentes cargados: ' + str(lt.size(catalog['accidentsList'])))
print ('Altura arbol: ' + str(map.height(catalog['accidentsTree'])))
datos_cargados = True
else:
print("Los datos ya han sido cargados")
elif int(inputs[0])==2: # 2- Buscar accidente por llave (fecha)
if datos_cargados:
fecha = pedir_fecha()
accidente = controller.getAccidentMap(catalog,fecha)
if accidente:
print("Accidente encontrado:\nID: ", accidente["accident_id"], "\nTiempo de inicio: ", accidente["start_time"], "\nTiempo de finalización: ", accidente["end_time"], "\nSeveridad tipo ", accidente["severity"], "\nLatitud ", accidente["start_lat"], "\nLongitud ", accidente["start_lng"])
else:
print("Accidente No encontrado")
else:
print("No ha cargado los datos")
elif int(inputs[0])==3: # 3- Consultar cuantos accidentes hubo antes a una fecha - (rank)
if datos_cargados:
print("Para consultar tiene que ingresar una fecha")
fecha = pedir_fecha()
rank = controller.rankAccidentMap(catalog, fecha)
print("Ocurrieron ", rank, " accidentes antes (rank) de la fecha ingresada")
else:
print("No ha cargado los datos")
elif int(inputs[0])==4: # 4- Consultar accidente por posición
if datos_cargados:
pos = int(input("Posición del k-esimo accidente del mapa (select) a obtener: "))
accidente = controller.selectAccidentMap(catalog, pos)
if accidente:
print("Accidente en posición:",pos,":\nID: ", accidente["accident_id"], "\nTiempo de inicio: ", accidente["start_time"], "\nTiempo de finalización: ", accidente["end_time"], "\nSeveridad tipo ", accidente["severity"], "\nLatitud : ", accidente["start_lat"], "\nLongitud : ", accidente["start_lng"])
else:
print("Accidente no encotrado en posicion: ",pos)
else:
print("No ha cargado los datos")
elif int(inputs[0])==5: # 5- Consultar total de accidentes ocurridos en una fecha específica. Estos totales se presentarán divididos entre las diferentes severidades de accidente posibles (1 - 4) y se mostrará la ciudad más accidentada por severidad en la fecha dada.
if datos_cargados:
print("Para ejecutar esta opción debe proporcionar una fecha (año, mes, día).\nEsta fecha debe estar dentro del rango de años de los datos cargados.\nNo tiene ingresar datos de hora, minuto o segundo ya que no se tendrán en cuenta.")
anio = int(input("Año del accidente: "))
mes = int(input("Mes(#) del accidente: "))
if mes < 10:
mes = "0"+str(mes)
dia = int(input("Día(#) del accidente: "))
if dia < 10:
dia = "0"+str(dia)
hora = 0
minuto = 0
segundo = 0
fecha = str(anio)+"-"+str(mes)+"-"+str(dia)+str(hora)+":"+str(minuto)+":"+str(segundo)
fecha = controller.sacarfecha(fecha)
fecha = int(((fecha-18000)//86400)-16801)
accidentes_año = map.get(catalog["accidentsByDate"], fecha, controller.greater)
if accidentes_año == None:
print("No hubo accidentes en esa fecha")
else:
print("En la fecha se presentaron ", accidentes_año["size"] , " accidentes.\n")
print("SEVERIDAD 1")
print("Para la severidad 1 se presentaron ", accidentes_año["data"][1]["size"], " accidentes en la fecha ingresada y la ciudad que más accidentes tuvo de este tipo fue: ", accidentes_año["data"][1]["ciudad_mas_accidentada"])
print("SEVERIDAD 2")
print("Para la severidad 2 se presentaron ", accidentes_año["data"][2]["size"], " accidentes en la fecha ingresada y la ciudad que más accidentes tuvo de este tipo fue: ", accidentes_año["data"][2]["ciudad_mas_accidentada"])
print("SEVERIDAD 3")
print("Para la severidad 3 se presentaron ", accidentes_año["data"][3]["size"], " accidentes en la fecha ingresada y la ciudad que más accidentes tuvo de este tipo fue: ", accidentes_año["data"][3]["ciudad_mas_accidentada"])
print("SEVERIDAD 4")
print("Para la severidad 4 se presentaron ", accidentes_año["data"][4]["size"], " accidentes en la fecha ingresada y la ciudad que más accidentes tuvo de este tipo fue: ", accidentes_año["data"][4]["ciudad_mas_accidentada"])
else:
print("No ha cargado los datos")
elif int(inputs[0])==6: # 6- Consultar total de accidentes ocurridos en un rango de fechas. Estos se mostraran divididos entre las diferentes ciudades.
if datos_cargados:
print("Para ejecutar esta opción debe proporcionar un rango de fechas, de modo que debe digitar dos fechas (año, mes, día).\nAl menos una fecha debe estar dentro del rango de años de los datos cargados.\nNo tiene ingresar datos de hora, minuto o segundo ya que no se tendrán en cuenta.")
print("Digite los datos para la primera fecha:")
anio = int(input("Año :"))
mes = int(input("Mes(#) :"))
if mes < 10:
mes = "0"+str(mes)
dia = int(input("Día(#) :"))
if dia < 10:
dia = "0"+str(dia)
hora = 0
minuto = 0
segundo = 0
fecha = str(anio)+"-"+str(mes)+"-"+str(dia)+str(hora)+":"+str(minuto)+":"+str(segundo)
fecha = controller.sacarfecha(fecha)
fecha1 = int(((fecha-18000)//86400)-16801)
print("Digite los datos para la segunda fecha:")
anio = int(input("Año :"))
mes = int(input("Mes(#) :"))
if mes < 10:
mes = "0"+str(mes)
dia = int(input("Día(#) :"))
if dia < 10:
dia = "0"+str(dia)
hora = 0
minuto = 0
segundo = 0
fecha = str(anio)+"-"+str(mes)+"-"+str(dia)+str(hora)+":"+str(minuto)+":"+str(segundo)
fecha = controller.sacarfecha(fecha)
fecha2 = int(((fecha-18000)//86400)-16801)
fecha1 = min(fecha1, fecha2)
fecha2 = max(fecha1, fecha2)
if fecha1 > 1460:
print("Ninguna de las dos fechas estan dentro del rango de datos")
else:
if fecha2 > 1460:
fecha2 = 1460
info = controller.DaterankAccidentMap(catalog, fecha1, fecha2)
ciudades = info["ciudades"]
if info["accidentes_totales"] == 0:
print("No hubo accidentes en esa fecha")
else:
print("En el rango de fechas dado sucedieron ", info["accidentes_totales"], "accidentes.")
print("A continuación se va a mostrar el número de accidentes por ciudad")
for ciudad in ciudades:
print(ciudad, " :", ciudades[ciudad])
else:
print("No ha cargado los datos")
elif int(inputs[0])==7: # 7- Consultar el estado con más accidentes en determinada fecha con su cantidad de accidentes.
if datos_cargados:
print("Para ejecutar esta opción debe proporcionar una fecha (año, mes, día).\nLa fecha debe estar dentro del rango de años de los datos cargados.\nNo tiene ingresar datos de hora, minuto o segundo ya que no se tendrán en cuenta.")
print("Digite los datos de la fecha:")
anio = int(input("Año :"))
mes = int(input("Mes(#) :"))
if mes < 10:
mes = "0"+str(mes)
dia = int(input("Día(#) :"))
if dia < 10:
dia = "0"+str(dia)
hora = 0
minuto = 0
segundo = 0
fecha = str(anio)+"-"+str(mes)+"-"+str(dia)+str(hora)+":"+str(minuto)+":"+str(segundo)
fecha = controller.sacarfecha(fecha)
fecha = int(((fecha-18000)//86400)-16801)
accidentes_año = map.get(catalog["accidentsByDate"], fecha, controller.greater)
if accidentes_año != None:
print("El estado más accidentado en la fecha ingresada es ", accidentes_año["data"]["estado_mas_accidentado"], " con ", accidentes_año["data"]["num_accidentes_estado_mas_accidentado"], " accidentes.")
else:
print("No hubo accidentes en la fecha ingresada")
else:
print("No ha cargado los datos")
else:
sys.exit(0)
sys.exit(0)
def getAccidentMap (catalog, fecha):
"""
Retorna el accidente desde el mapa a partir de la fecha (key)
"""
return map.get(catalog['accidentsTree'], fecha, greater)
def getBookTree (catalog, bookTitle):
"""
Retorna el libro desde el mapa a partir del titulo (key)
"""
return tree.get(catalog['booksTitleTree'], bookTitle, greater)
