def directoresSize(catalog):
return mp.size(catalog['directores'])
def voteAverageSize(catalog):
return mp.size(catalog['voteAverage'])
def thread_cycle():
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n>')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
catalog = controller.loadData(connectionsfile, landingpointsfile,
countriesfile)
lps = lt.firstElement(mp.keySet(catalog["landingpoints"]))
lp_info = mp.get(catalog["landingpoints"], lps)['value']['info']
lp_infos = mp.get(catalog["landingpoints"],
lps)['value']['lstcables']
print("Cantidad de Landing Points: ",
mp.size(catalog["landingpoints"]))
print("Cantidad de conexiones entre Landing Points: ",
gr.numEdges(catalog["internet_graph"]))
print("Cantidad de paises: ", mp.size(catalog["countries"]))
lps = lt.firstElement(mp.keySet(catalog["landingpoints"]))
lp_info = mp.get(catalog["landingpoints"], lps)['value']['info']
print('Primer landingpoint')
print("Landing point id: ", lp_info['landing_point_id'], "id: ",
lp_info['id'], "name: ", lp_info['name'], "latitude: ",
lp_info['latitude'], "Longitude: ", lp_info["longitude"])
countries = lt.firstElement(mp.keySet(catalog["countries"]))
country_info = mp.get(catalog["countries"], countries)['value']
print('Primer pais')
print('CountryName: ', country_info['CountryName'], "Population: ",
country_info['Population'], "Internet users: ",
country_info['Internet users'])
elif int(inputs[0]) == 2:
lp1 = input('Ingrese el nombre del primer landing point: ')
lp2 = input('Ingrese el nombre del segundo landing point: ')
optionTwo(catalog, lp1, lp2)
elif int(inputs[0]) == 3:
optionThree(catalog)
elif int(inputs[0]) == 4:
country_1 = input('Ingrese el primer país: ')
country_2 = input('Ingrese el segundo país: ')
optionFour(catalog, country_1, country_2)
elif int(inputs[0]) == 5:
optionFive(catalog)
elif int(inputs[0]) == 6:
landingpoint = input('Ingrese el landinpoint: ')
optionSix(catalog, landingpoint)
elif int(inputs[0]) == 7:
optionSeven(catalog)
elif int(inputs[0]) == 8:
optionEight(catalog)
else:
sys.exit(0)
sys.exit(0)
def actorsSize(catalog):
return mp.size(catalog['actors'])
def productionCompaniesSize(catalog):
return mp.size(catalog['productionCompanies'])
def tagsSize(catalog):
"""
Numero de tags en el catalogo
"""
return mp.size(catalog['tags'])
def cabsSize(catalog):
"""
Informa el número total de taxis en los servicios reportados
"""
size = m.size(catalog['totalCabs'])
return size
def CountrySize(analyzer):
return mp.size(analyzer["countries"])
def addMapLanding_points(catalog, element):
"""
Guarda la informacion del CSV landing_point en tablas de hash
que contiene tablas de hash con las ciudades
"""
# Verificar si no existe el landing_point
idEsta = mp.contains(catalog['map_landing_points'],
element['landing_point_id'])
# Verifica si es el primer landing_point
if not idEsta and (mp.size(catalog['map_landing_points']) == 0):
# Se crea una tabla de hash que contiene como Key una ciudad y como value la informacion del landing point
cities_map = mp.newMap(numelements=15,
maptype='PROBING',
loadfactor=0.4)
# Se separa las ciudades del landing_point
cities = element['name'].split(",")
# Se itera por cada ciudad para ver si es el pais
for city in cities:
CapitalName = city.strip(" ")
# Se verifica si el pais esta en la tabla de hash de pais
if mp.contains(catalog['map_countries'], CapitalName):
# Si no se encuentra la ciudad capital se mete
if not mp.contains(cities_map, city):
countryEntry = mp.get(catalog['map_countries'],
CapitalName)
country = me.getValue(countryEntry)
capital = country['CapitalName']
mp.put(cities_map, capital, element)
else:
# Si no se encuentra la ciudad se mete
if not mp.contains(cities_map, city):
mp.put(cities_map, city, element)
mp.put(catalog['map_landing_points'], element['landing_point_id'],
cities_map)
#Datos a retornar
print("El primer landing_point cargado es: " + str(element['id']))
print("El nombre es: " + str(element['name']))
print("La latitude es: " + str(element['latitude']))
print("La longitude es: " + str(element['longitude']))
elif not idEsta:
# Se crea una tabla de hash que contiene como Key una ciudad y como value la informacion del landing point
cities_map = mp.newMap(numelements=10,
maptype='PROBING',
loadfactor=0.4)
# Se separa las ciudades del landing_point
cities = element['name'].split(",")
# Se itera por cada ciudad para ver si es el pais
for city in cities:
CapitalName = city.strip(" ")
# Se verifica si el pais esta en la tabla de hash de pais
if mp.contains(catalog['map_countries'], CapitalName):
# Si no se encuentra la ciudad capital se mete
if not mp.contains(cities_map, city):
countryEntry = mp.get(catalog['map_countries'],
CapitalName)
country = me.getValue(countryEntry)
capital = country['CapitalName']
mp.put(cities_map, capital, element)
else:
# Si no se encuentra la ciudad se mete
if not mp.contains(cities_map, city):
mp.put(cities_map, city, element)
mp.put(catalog['map_landing_points'], element['landing_point_id'],
cities_map)
def trackSize(analyzer):
"""
Número de libros en el catago
"""
return mp.size(analyzer['track_ID'])
def elementsSize(catalog, element):
"""
Numero de autores en el catalogo
"""
return mp.size(catalog[element])
def artistSize(analyzer):
"""
Número de libros en el catago
"""
return mp.size(analyzer['artist_ID'])
def castingSize(catalog):
return mp.size(catalog['casting'])
def countriesSize(catalog):
return mp.size(catalog['country'])
def CountriesSize(catalog):
return mp.size(catalog['countries'])
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Inicializando Catálogo ....")
catalog = controller.iniciarcatalog()
print("Se ha inicializado el catalogo...")
elif int(inputs[0]) == 2:
print("Cargando información de los archivos ....")
controller.loadDatos(catalog)
print('Peliculas cargados: ' + str(lt.size(catalog['Peliculas'])))
print('Directores cargados: ' + str(mp.size(catalog['Directores'])))
print('Géneros cargados: ' + str(mp.size(catalog['Generos'])))
print("Productoras cargadas: " + str(mp.size(catalog['Productoras'])))
print("Paises cargados: " + str(mp.size(catalog['Paises'])))
print("Actores cargados: " + str(mp.size(catalog['Actores'])), "\n")
pelicula1 = lt.getElement(catalog["Peliculas"], 1)
pelicula2 = lt.getElement(catalog["Peliculas"],
lt.size(catalog["Peliculas"]))
print("La primera pelicula es:", "\n\n", "Titulada:",
pelicula1["original_title"], "\n", "Estrenada el dia:",
pelicula1["release_date"])
print(" Su promedio de votacion:", pelicula1["vote_average"], "\n",
"su numero de votos", pelicula1["vote_count"], "\n",
"Y su idioma:", pelicula1["original_language"], "\n")
print("La ultima pelicula es:", "\n\n", "Titulada:",
pelicula2["original_title"], "\n", "Estrenada el dia:",
def authorsSize(catalog):
"""
Numero de autores en el catalogo
"""
return mp.size(catalog['authors'])
print("Cargando información de los archivos ....")
# cont es el controlador que se usará de acá en adelante
analyzer = controller.init()
controller.loadEvents(analyzer)
controller.loadUserTrack(analyzer)
controller.loadSentimentValues(analyzer)
newTreeReq4 = controller.getCar(analyzer, 'tempo') # árbol según valores de "tempo"
genreMap = controller.genreMap(newTreeReq4)
print("Cantidad de Eventos: {0}".format(lt.size(analyzer['eventos'])))
print("Cantidad de Artistas: {0}".format(mp.size(analyzer['artistas'])))
print("Cantidad de Tracks: {0}".format(mp.size(analyzer['audios'])))
elif int(inputs[0]) == 2:
print("\n++++++ Req No. 1 results... ++++++\n")
car = input("Ingrese la característica de contenido que desea:\n~") # Test con 'instrumentalness'
bajo = float(input("Ingrese el mínimo del rango:\n~"))
alto = float(input("Ingrese el máximo del rango:\n~"))
print("\nCargando datos según la característica....")
newTree = controller.getCar(analyzer, car)
def companiesSize(catalog):
"""
Informa el número de compañías con al menos un taxi inscrito
"""
size = m.size(catalog['companies'])
return size
"""
while True:
printMenu()
inputs = input('Seleccione una opci贸n para continuar\n>')
if int(inputs[0]) == 1:
print("\nInicializando....")
# analyzer es el controlador que se usar谩 de ac谩 en adelante
analyzer = controller.init()
print("\nAnalizador cargado.")
elif int(inputs[0]) == 2:
print("\nCargando informaci贸n de accidentes ....")
controller.loadData(analyzer, file)
print("\nInformacion caragada exitosamente")
print("Se cargaron", m.size(analyzer["accidentes"]), "elementos.")
print("altura del arbol fechas", om.height(analyzer["index"]))
print("elementos del arbol fechas", om.size(analyzer["index"]))
print("tama帽o del arbol horas", om.height(analyzer["index_horas"]))
print("elementos del arbol horas", om.size(analyzer["index_horas"]))
elif int(inputs[0]) == 3:
criterio = input(str("\nBuscando accidentes en un rango de fechas: "))
Monika = controller.obtener_accidentes_por_fecha(analyzer, criterio)
impresor_de_datos_elefante_de_batalla_psiquico_ancestral(Monika)
elif int(inputs[0]) == 4:
fecha1 = str(om.minKey(analyzer["index"]))
fecha2 = input("\nIngrese una fecha (YYYY-MM-DD): ")
listafechas = controller.accidentes_antes_de_una_fecha(
analyzer, fecha1, fecha2)
print("*******************************************")
def MoviesIdsSize(catalog):
return mp.size(catalog['moviesIds'])
def tamano(catalog):
return mp.size(catalog["directores"])
def genresSize(catalog):
return mp.size(catalog['genres'])
def totalCountries(analyzer):
"""
Retorna la cantidad total de países
"""
return mp.size(analyzer['countries'])
def countriesSize(catalog):
return mp.size(catalog['productionCountries'])
def statesSize(catalog):
"""
RETO3 - REQ4
Número de estados cargados.
"""
return m.size(catalog['States'])
def voteCountSize(catalog):
return mp.size(catalog['voteCount'])
"""
Menu principal
"""
while True:
printMenu()
inputs = input('Seleccione una opción para continuar\n')
if int(inputs[0]) == 1:
print("Cargando información de los archivos ....")
analyzer = controller.init()
data = controller.loadData(analyzer)
grafo = analyzer['connections']
grafo_direc = analyzer['connections_directed']
print('El numero de landing points es: ' +
str(om.size(analyzer['landing_points'])))
print('El numero total de paises es: ' +
str(mp.size(analyzer['countries'])))
print('El numero de conexiones entre landing points (arcos) es: ' +
str(gr.numEdges(analyzer['connections'])))
elif int(inputs[0]) == 2:
landing1 = input('Ingrese el nombre del landing point 1: ')
landing2 = input('Ingrese el nombre del landing point 2: ')
controller.Requerimiento1(analyzer, landing1, landing2)
elif int(inputs[0]) == 3:
ans = controller.Requerimiento2(analyzer)
j = 0
for i in lt.iterator(ans):
j += 1
if j == 11:
break
def getgenre(maps, genretuple, table, table2):
'''
Funcion que define el genero que mas reproducciones tiene.
despues busca los hashtags que tiene cada track dentro del
genero top y retorna una lista con el track, la cantidad de
hashtags que tiene y el vader promedio.
'''
# Se guarda la informacion de los videos por tracks_id
newmap = om.newMap(omaptype='RBT')
# Busca cual es el genero que es el top
if genretuple[0] == "Reggae":
value = om.values(maps, 60, 90)
elif genretuple[0] == "Down-tempo":
value = om.values(maps, 70, 100)
elif genretuple[0] == "Chill-out":
value = om.values(maps, 90, 120)
elif genretuple[0] == "Hip-hop":
value = om.values(maps, 85, 115)
elif genretuple[0] == "Jazz and Funk":
value = om.values(maps, 120, 125)
elif genretuple[0] == "Pop":
value = om.values(maps, 100, 130)
elif genretuple[0] == "R&B":
value = om.values(maps, 60, 80)
elif genretuple[0] == "Rock":
value = om.values(maps, 110, 140)
elif genretuple[0] == "Metal":
value = om.values(maps, 100, 160)
# Recorre la lista de valores del genero top
iterator = ite.newIterator(value)
while ite.hasNext(iterator):
eventslist = ite.next(iterator)
newiterator = ite.newIterator(eventslist['lstevent'])
while ite.hasNext(newiterator):
event = ite.next(newiterator)
entry = om.get(newmap, event['track_id'])
if entry is None:
dataentry = newDataEntry(event)
om.put(newmap, event['track_id'], dataentry)
else:
dataentry = me.getValue(entry)
addEntry(dataentry, event)
# se crea una lista con todos los tracks_id
tracksid = om.keySet(newmap)
finallist = lt.newList("ARRAY_LIST")
'''
Se recorren cada uno de los id para sacar la informacion
y compararla con el mapa de hashtags
'''
tracksiterator = ite.newIterator(tracksid)
while ite.hasNext(tracksiterator):
info = ite.next(tracksiterator)
entry = mp.get(table, info)
entryvalue = me.getValue(entry)
# Es una tabla de has temporal donde se guardan los hashtags
hasht = mp.newMap(numelements=15, maptype='PROBING', loadfactor=0.5)
newiterator = ite.newIterator(entryvalue['lstevent'])
# Aca se comenzaran a sumar los vaders
sumvader = 0
while ite.hasNext(newiterator):
trackhash = ite.next(newiterator)
hashtag = trackhash['hashtag'].lower()
mp.put(hasht, hashtag, 0)
# Se saca la informacion de la tabal de vader
vader = mp.get(table2, hashtag)
if vader is None:
break
else:
vadevalue = me.getValue(vader)
juandiego = ite.newIterator(vadevalue['lstevent'])
while ite.hasNext(juandiego):
pos = ite.next(juandiego)
# Hay valores de vader que no existen
if pos['vader_avg'] == '':
sumvader += 0
else:
averagevader = float(pos['vader_avg'])
sumvader += averagevader
nohash = mp.size(hasht)
# Se saca el promedio de vader
avgvader = round(sumvader / nohash, 1)
lt.addLast(finallist, (info, nohash, avgvader))
return finallist
def productorasSize(catalog):
return mp.size(catalog['productoras'])
