def addVideoChannel(catalog, video):
"""
Esta funcion adiciona un video a la lista de videos que
fueron publicados en un canal especifico.
"""
try:
channels = catalog['channels']
if (video['channel_title'] == ''):
return
videochannel = video['channel_title']
existchannel = mp.contains(channels, videochannel)
if existchannel:
entry = mp.get(channels, videochannel)
channel = me.getValue(entry)
else:
channel = newChannel(videochannel)
mp.put(channels, videochannel, channel)
lt.addLast(channel['videos'], video)
except Exception:
return None
def matchTempo(catalog, tempo, genre_reps, track):
genre_map = catalog['genre_dictionary']
for genre in lt.iterator(mp.keySet(genre_map)):
ranges = me.getValue(mp.get(genre_map, genre))
if ranges['min'] <= float(tempo) <= ranges['max']:
g_reps = mp.get(genre_reps, genre)
if g_reps is None:
reps = 0
# tracks = lt.newList(datastructure='ARRAY_LIST')
tracks = mp.newMap()
else:
reps = me.getValue(g_reps)['reps']
tracks = me.getValue(g_reps)['tracks']
reps += 1
# lt.addLast(tracks, track)
mp.put(tracks, track, 1)
mp.put(genre_reps, genre, {'reps': reps, 'tracks': tracks})
return catalog
def addDirectors(catalogo, casting):
directors = catalogo['directors']
nombre_director = casting['director_name']
existedirector = mp.contains(directors, nombre_director)
if existedirector:
entrada_director = mp.get(
directors, nombre_director
) # devuelve la key , value. Key nombre del director, y el value todo el dic del director
el_director = me.getValue(
entrada_director) # deb deser retorna le valor
else:
el_director = newDirector(
casting['director_name']
) #crea un nuevo "valor" para key: nombre director
mp.put(
directors, nombre_director, el_director
) # mete en el mapa directors, una key con nombre director y valor el_director
el_director['cantidad_peliculas'] = int(
el_director['cantidad_peliculas']) + 1
lt.addLast(el_director['movies'], casting)
def addBookAuthor(catalog, authorname, book):
"""
Esta función adiciona un libro a la lista de libros publicados
por un autor.
Cuando se adiciona el libro se actualiza el promedio de dicho autor
"""
authors = catalog['authors']
existauthor = mp.contains(authors, authorname)
if existauthor:
entry = mp.get(authors, authorname)
author = me.getValue(entry)
else:
author = newAuthor(authorname)
mp.put(authors, authorname, author)
lt.addLast(author['books'], book)
authavg = author['average_rating']
bookavg = book['average_rating']
if (authavg == 0.0):
author['average_rating'] = float(bookavg)
else:
author['average_rating'] = (authavg + float(bookavg)) / 2
def relaxingMusic(catalog, min_instrumentalness, max_instrumentalness,
min_tempo, max_tempo):
instrumentalness_tree = me.getValue(
mp.get(catalog['content_cateogries'], 'instrumentalness'))
instrumentalness_values = om.values(instrumentalness_tree,
min_instrumentalness,
max_instrumentalness)
unique_tracks = mp.newMap(numelements=5000,
maptype='CHAINING',
comparefunction=cmpCategories)
final_items = lt.newList(datastructure='ARRAY_LIST')
for sublist in lt.iterator(instrumentalness_values):
for event in lt.iterator(sublist):
if checkWithUser(catalog, event):
if min_tempo <= float(event['tempo']) <= max_tempo:
lt.addLast(final_items, event)
mp.put(unique_tracks, event['track_id'], event)
tracks = mp.size(unique_tracks)
return final_items, tracks
def addCategoriaa(diccio):
iterador = it.newIterator(diccio["videos"])
while it.hasNext(iterador):
actual = it.next(iterador)
actual["category_id"]
if mp.contains(diccio["categorias"], actual["category_id"]) == True:
par = mp.get(diccio['categorias'], actual["category_id"])
lis = me.getValue(par)
lt.addLast(lis, actual)
else:
lis = lt.newList()
mp.put(diccio['categorias'], actual["category_id"], lis)
lt.addLast(lis, actual)
return diccio
def addDirector(catalog, movie):
"""
Esta función adiciona una pelicula por su director en el map
"""
directors = catalog['director']
director_name = movie["director_name"].lower()
movie_avg = movie['vote_average']
title = movie["title"]
if director_name != "none":
existDirector = mp.contains(directors, director_name)
if existDirector:
entry = mp.get(directors, director_name)
director = me.getValue(entry)
else:
director = newDirector(director_name)
mp.put(directors, director_name, director)
lt.addLast(director['movies'], title)
director_avg = director['vote_average']
if (director_avg == 0.0):
director['vote_average'] = float(movie_avg)
else:
director['vote_average'] = director_avg + float(movie_avg)
def sinMar(analyzer, country, city):
info = mp.get(analyzer["countries"], country)["value"]
location = (float(info["CapitalLatitude"]),
float(info["CapitalLongitude"]))
lista3 = mp.keySet(analyzer["vertices"])
lista_final = lt.newList(datastructure="ARRAY_LIST")
i = 1
while i <= lt.size(lista3):
country = lt.getElement(lista3, i)
mapa = mp.get(analyzer["vertices"], country)["value"]
lista2 = mp.keySet(mapa)
ii = 1
while ii <= lt.size(lista2):
lp_name = lt.getElement(lista2, ii)
lp = mp.get(mapa, lp_name)["value"]
location_lp = mp.get(analyzer["location_dado_id"],
lp_name[0])["value"]
capacity = float(lp["capacityTBPS"])
distance = hs.haversine(location_lp, location)
lt.addLast(lista_final, (lp_name, distance, capacity))
ii += 1
i += 1
lista_sorteada = mrge.sort(lista_final, cmpSinMar)
tupla = lt.getElement(lista_sorteada, 1)
cost = {"distance": tupla[1], "capacity": float(tupla[2])}
edge_identifier = (tupla[0], (city, 0))
mp.put(analyzer["edges"], edge_identifier, cost)
gr.addEdge(analyzer["connections_distance"], tupla[0], (city, 0),
cost["distance"])
gr.addEdge(analyzer["connections_distance"], (city, 0), tupla[0],
cost["distance"])
gr.addEdge(analyzer["connections_capacity"], tupla[0], (city, 0),
cost["capacity"])
gr.addEdge(analyzer["connections_capacity"], (city, 0), tupla[0],
cost["capacity"])
def addProductionCompany(catalog, movie):
"""
Esta función adiciona una pelicula por su productora en el map
"""
ProductionCompanies = catalog['productionCompany']
comp_name = movie["production_companies"].lower()
existProd_Comp = mp.contains(ProductionCompanies, comp_name)
title = movie["title"]
if existProd_Comp:
entry = mp.get(ProductionCompanies, comp_name)
company = me.getValue(entry)
else:
company = newProductionCompany(comp_name)
mp.put(ProductionCompanies, comp_name, company)
lt.addLast(company['movies'], title)
comp_avg = company['vote_average']
movie_avg = movie['vote_average']
if (comp_avg == 0.0):
company['vote_average'] = float(movie_avg)
else:
company['vote_average'] = comp_avg + float(movie_avg)
def addConexion(catalog, conexion):
point_salida = conexion["origin"]
point_llegada = conexion["destination"]
vertice_salida = point_salida + "-" + conexion["cable_name"]
vertice_llegada = point_llegada + "-" + conexion["cable_name"]
#1. Se añade la conexión al grafo de Ancho de banda
ancho = conexion["capacityTBPS"]
addAncho(catalog, vertice_salida, vertice_llegada, ancho)
mapa_info_point1 = me.getValue(mp.get(catalog["points"], point_salida))
latitud1 = me.getValue(mp.get(mapa_info_point1, "latitude"))
longitud1 = me.getValue(mp.get(mapa_info_point1, "longitude"))
mapa_info_point2 = me.getValue(mp.get(catalog["points"], point_llegada))
latitud2 = me.getValue(mp.get(mapa_info_point2, "latitude"))
longitud2 = me.getValue(mp.get(mapa_info_point2, "longitude"))
distancia = CalcularPeso(latitud1, longitud1, latitud2, longitud2)
#2. Se añade la conexión al grafo normal (de distancia)
addDistance(catalog, vertice_salida, vertice_llegada, distancia)
#3. Se añaden a la MinPQ asociada a cada Landing_Point
addAnchoQueue(catalog, point_salida, ancho)
addAnchoQueue(catalog, point_llegada, ancho)
#4. Añade el vertice a la lista de vertices del mapa de points
mapa_vertices1 = me.getValue(mp.get(mapa_info_point1, "mapa_vertices"))
mp.put(mapa_vertices1, vertice_salida, None)
mapa_vertices2 = me.getValue(mp.get(mapa_info_point2, "mapa_vertices"))
mp.put(mapa_vertices2, vertice_llegada, None)
#5. Añade los vértices al mapa de vértices para un cable dado dentro del mapa de cables
addCable(catalog, conexion["cable_name"], vertice_salida, vertice_llegada)
#6. Añade los vértices al mapa de vértices dado un país
pais1 = me.getValue(mp.get(mapa_info_point1, "country"))
addVertexToCountries(catalog, pais1, vertice_salida)
pais2 = me.getValue(mp.get(mapa_info_point2, "country"))
addVertexToCountries(catalog, pais2, vertice_llegada)
def addVideoCountry(catalog, video):
"""
Esta funcion adiciona un video a la lista de videos que
fueron publicados en un país especifico.
"""
try:
countries = catalog['countries']
if (video['country'] == ''):
return
videocountry = video['country']
existcountry = mp.contains(countries, videocountry)
if existcountry:
entry = mp.get(countries, videocountry)
country = me.getValue(entry)
else:
country = newCountry(videocountry)
mp.put(countries, videocountry, country)
lt.addLast(country['videos'], video)
except Exception:
return None
def addCountryCategorySorted(catalog, videoname):
category_id = videoname["category_id"]
category = (mp.get(catalog["categories"],
category_id))["value"]["category_name"]
country = videoname["country"]
if mp.contains(catalog["country_category_sorted"],
country + "/" + category):
list_exists = mp.get(catalog["country_category_sorted"],
country + "/" + category)["value"]
lt.addLast(list_exists, videoname)
mp.put(catalog["country_category_sorted"], country + "/" + category,
list_exists)
else:
mp.put(catalog["country_category_sorted"], country + "/" + category,
lt.newList("ARRAY_LIST"))
new_list = mp.get(catalog["country_category_sorted"],
country + "/" + category)["value"]
lt.addLast(new_list, videoname)
def newDataEntry(catalogo,track,caracteristica):
entrada = mp.newMap(numelements=10,maptype='PROBING',loadfactor=0.5)
for caracteristica in catalogo:
if caracteristica!='tracks':
mp.put(entrada,caracteristica,track[caracteristica])
mp.put(entrada,'track_id',track['track_id'])
mp.put(entrada,'user_id',track['user_id'])
return entrada
def req4(catalog, listaGeneros):
numEventos = 0
datos = lt.newList(datastructure= "SINGLE_LINKED")
for genero in listaGeneros:
numEventosGenero = 0
artistas = mp.newMap(maptype= "CHAINING")
entry = mp.get(catalog["generos-intervalos"], genero)
nombre = me.getKey(entry)
intervalo = me.getValue(entry)
llaves = om.keys(catalog["tempo"], intervalo[0], intervalo[1])
for llave in lt.iterator(llaves):
entry = om.get(catalog["tempo"], llave)
tracks = me.getValue(entry)
for referencia in lt.iterator(tracks):
track = lt.getElement(catalog["lista_canciones"], referencia)
numEventos += 1
numEventosGenero += 1
mp.put(artistas, track["artist_id"], None)
sizeArtistas = mp.size(artistas)
top10 = lt.subList(mp.keySet(artistas), 1, 10)
lt.addLast(datos, (nombre, numEventosGenero, sizeArtistas, top10))
return (numEventos, datos)
def getFirstVideoByTrendDays(catalog):
"""
Retorna el video con mayor número de trending days
"""
videoidsmap = mp.newMap(200000,
maptype='CHAINING',
loadfactor=4.0,
comparefunction=compareMapVideosids)
try:
for video in lt.iterator(catalog):
videoid = video['video_id']
existvideoid = mp.contains(videoidsmap, videoid)
if existvideoid:
entry = mp.get(videoidsmap, videoid)
id = me.getValue(entry)
else:
id = newVideoid(videoid)
mp.put(videoidsmap, videoid, id)
lt.addLast(id['videos'], video)
id['trendingdays'] = lt.size(id['videos'])
except Exception:
return None
mp.remove(videoidsmap, '#NAME?')
videoids = mp.keySet(videoidsmap)
try:
maxTrendDays = 0
firstVideo = None
for videoid in lt.iterator(videoids):
entry = mp.get(videoidsmap, videoid)
trendDays = me.getValue(entry)['trendingdays']
if trendDays > maxTrendDays:
maxTrendDays = trendDays
firstVideo = entry
return firstVideo
except Exception:
return None
def DepthFirstSearch2(graph, source, components):
"""
Genera un recorrido DFS sobre el grafo graph
Args:
graph: El grafo a recorrer
source: Vertice de inicio del recorrido.
Returns:
Una estructura para determinar los vertices
conectados a source
Raises:
Exception
"""
try:
search = {
'source': source,
'visited': None,
}
search['visited'] = map.newMap(
numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
path = stk.newStack()
cycles = [[]]
weights = [0]
map.put(search['visited'], source, {'marked': True, 'edgeTo': None})
dfs_extra(search, graph, source, components, path, cycles, weights)
cycles.pop()
weights.pop()
for i in range(len(weights)):
weights[i]
return (cycles, weights)
except Exception as exp:
error.reraise(exp, 'dfs:DFS')
def addLandConnection(analyzer, connection):
"""
Adiciona los vértices al grafo con el formato:
código*nombre_del_cable
Añade conexiones entre los vértices tomando como peso
la distancia entre los 2 puntos calculada con la
función de haversine
Guarda los vértices con el mismo código inicial
en el mapa relatedVertex
"""
congr = analyzer['connections'] #connections graph = congr
rela = analyzer['relatedVertex']
points = analyzer['points']
try:
origin = connection['origin']
oriPoint = me.getValue(m.get(points, origin))
verOrigin = formatVertex(connection, 'origin')
addVertex(congr, verOrigin)
destination = connection['destination']
destPoint = me.getValue(m.get(points, destination))
verDest = formatVertex(connection, 'destination')
addVertex(congr, verDest)
distance = haversine(oriPoint, destPoint)
addConnection(congr, verOrigin, verDest, distance)
esta = m.get(rela, origin)
if esta is not None:
lista = me.getValue(esta)
if lt.isPresent(lista, verOrigin) == False:
lt.addLast(lista, verOrigin)
else:
listaVertex = lt.newList(datastructure='ARRAY_LIST')
lt.addLast(listaVertex, verOrigin)
m.put(rela, origin, listaVertex)
return analyzer
except Exception as exp:
error.reraise(exp, 'model:addLandConnection')
def initSearch(graph, source):
"""
Inicializa la estructura de busqueda y deja
todos los arcos en infinito.
Se inserta en la cola indexada el vertice source
Args:
graph: El grafo a examinar
source: El vertice fuente
Returns:
Estructura de busqueda inicializada
Raises:
Exception
"""
try:
search = {'source': source, 'visited': None, 'iminpq': None}
search['visited'] = map.newMap(
numelements=g.numVertices(graph),
maptype='PROBING',
comparefunction=graph['comparefunction'])
vertices = g.vertices(graph)
for vert in lt.iterator(vertices):
map.put(search['visited'], vert, {
'marked': False,
'edgeTo': None,
'distTo': math.inf
})
map.put(search['visited'], source, {
'marked': True,
'edgeTo': None,
'distTo': 0
})
pq = iminpq.newIndexMinPQ(cmpfunction=graph['comparefunction'])
search['iminpq'] = pq
iminpq.insert(search['iminpq'], source, 0)
return search
except Exception as exp:
error.reraise(exp, 'dks:init')
def updateFeatures(table, event):
'''Todos los features estan en una tabla de Hash, el key es el feature y el value es un rbt
este rbt tiene key un valor de instrumentalness (por ejemplo) y como valor un diccionario
el diccionario tiene dos elementos:
el elemento ['valueevents'] que contiene una array list con todos los eventos de reproduccion
el elemento ['track_ids'] que contiene un hash table con key = track_id y value = evento con ese track id
el anadido fue el segundo elemento.
Lo hice de esta manera para poder completar los requerimientos 2 y 3, que piden reproducciones unicas y comparar diccionarios.
Otra cosa es que ahora solo se crean RBTs para features con valores que tiene sentido comparar, antes se creaba para todo feature
Ademas hice cambios para que los keys de los RBT sean floats, antes eran strings.
'''
i = 1
for feature in event:
if mp.size(table) < 9:
tree = om.newMap(omaptype='RBT', comparefunction=cmpFunction)
dict = {'valueevents': None, 'track_ids': None}
dict['valueevents'] = lt.newList(datastructure='ARRAY_LIST')
dict['track_ids'] = mp.newMap(maptype='PROBING', loadfactor=0.5)
lt.addLast(dict['valueevents'], event)
mp.put(dict['track_ids'], event['track_id'], event)
om.put(tree, float(event[feature]), dict)
mp.put(table, feature, tree)
else:
tree = me.getValue(mp.get(table, feature))
if om.contains(tree, float(event[feature])):
dict = me.getValue(om.get(tree, float(event[feature])))
lt.addLast(dict['valueevents'], event)
mp.put(dict['track_ids'], event['track_id'], event)
else:
dict = {'valueevents': None, 'track_ids': None}
dict['track_ids'] = mp.newMap(maptype='PROBING',
loadfactor=0.5)
dict['valueevents'] = lt.newList(datastructure='ARRAY_LIST')
lt.addLast(dict['valueevents'], event)
mp.put(dict['track_ids'], event['track_id'], event)
om.put(tree, float(event[feature]), dict)
if i == 9:
break
i += 1
def countryid(lista, ide):
"""
Devuelve un mapa con videos de un category_id en particular, a partir de la lista de videos ya filtrada por pais, cuyas llaves son los títulos de los videos y cuyos valores son entradas de newtviews
"""
mapa = mp.newMap(numelements=4096, maptype="PROBING", loadfactor=0.5)
i = it.newIterator(lista)
while it.hasNext(i):
vid = it.next(i)
if vid['category_id'] == ide:
tit = vid["title"]
existit = mp.contains(mapa, tit)
if existit:
entry = mp.get(mapa, tit)
value = me.getValue(entry)
if vid["views"] > value["views"]:
value["views"] = vid["views"]
else:
entry = newtviews(vid['title'])
mp.put(mapa, vid['title'], entry)
entry['views'] = vid['views']
entry['info'] = vid
return mapa
def getPointsV2(database: DataBase, date1, date2) -> dict:
days = database.getDays()
days = orderedmap.values(days, date1, date2)
days = lti.newIterator(days)
top = map.newMap(comparefunction=cmp.compareId)
while lti.hasNext(days):
day = lti.next(days).points
day = map.valueSet(day)
day = lti.newIterator(day)
while lti.hasNext(day):
wallet = lti.next(day)
if map.contains(top, wallet.id):
node = map.get(top, wallet.id)
value = mapentry.getValue(node)
value['points'] += wallet.points
else:
value = {'id': wallet.id, 'points': wallet.points}
map.put(top, wallet.id, value)
top = map.valueSet(top)
sort.mergesort(top, cmp.points)
return top
def getAccidentsByTime(analyzer, initialTime, finalTime):
accidents = om.values(analyzer['timeIndex'], initialTime, finalTime)
lstiterator = it.newIterator(accidents)
SeverityMap = m.newMap(numelements=8,
maptype='PROBING',
comparefunction=CompareAccidentsState)
for i in range(1, 5):
m.put(SeverityMap, str(i), 0)
while (it.hasNext(lstiterator)):
eachtime = it.next(lstiterator)
SeverityMapEachTime = eachtime["SeverityIndex"]
accidents = eachtime['lstAccidents']
accidents = lt.size(accidents)
SeverityList = m.keySet(SeverityMapEachTime)
SeverityIterator = it.newIterator(SeverityList)
while (it.hasNext(SeverityIterator)):
severityRange = it.next(SeverityIterator)
ValueEachtime = lt.size(
me.getValue(m.get(SeverityMapEachTime, severityRange)))
ValueSeverity = (me.getValue(m.get(SeverityMap, severityRange)))
numberAccidents = ValueEachtime + ValueSeverity
m.put(SeverityMap, severityRange, numberAccidents)
return SeverityMap
def addMovieGenre(catalog, genrename, movie):
"""
Esta función adiciona un libro a la lista de libros publicados
por un autor.
Cuando se adiciona el libro se actualiza el promedio de dicho autor
"""
genres = catalog['Generos']
existgenre = mp.contains(genres, genrename)
if existgenre:
entry = mp.get(genres, genrename)
genre = me.getValue(entry)
else:
genre = newGenre(genrename)
mp.put(genres, genrename, genre)
lt.addLast(genre['movie'], movie)
genreavg = genre['average_rating']
movieavg = movie['vote_count']
if (genreavg == 0.0):
genre['average_rating'] = float(movieavg)
else:
genre['average_rating'] = (genreavg + float(movieavg)) / 2
return catalog
def addmovietoactor(catalog, actorname, movie_id):
actors = catalog['actors']
directors = catalog['directors']
movies_ids = catalog['moviesIds']
entry = mp.get(movies_ids, movie_id)
movie = me.getValue(entry)
existactor = mp.contains(actors, actorname)
if existactor:
entry = mp.get(actors, actorname)
actor = me.getValue(entry)
else:
actor = newActor(actorname)
mp.put(catalog['actors'], actorname, actor)
lt.addLast(actor['movies'], movie)
actor_mov_Avg = actor['average_rating']
movieAvg = movie['vote_average']
if (actor_mov_Avg == 0.0):
actor['average_rating'] = float(movieAvg)
else:
actor['average_rating'] = round((actor_mov_Avg + float(movieAvg)) / 2,
2)
def addEvent(analyzer, event):
'''
Agrega individualmente el evento al analyzer, en
cada uno de sus mapas
'''
lt.addLast(analyzer['events'], event)
mp.put(analyzer['artists'], event['artist_id'], 0)
addTrackOnOrderedRBTMap(analyzer, event['track_id'], event, 'tracks')
addEventOnOrderedRBTMap(analyzer, float(event['instrumentalness']), event,
'instrumentalness')
addEventOnOrderedRBTMap(analyzer, float(event['acousticness']), event,
'acousticness')
addEventOnOrderedRBTMap(analyzer, float(event['liveness']), event,
'liveness')
addEventOnOrderedRBTMap(analyzer, float(event['speechiness']), event,
'speechiness')
addEventOnOrderedRBTMap(analyzer, float(event['energy']), event, 'energy')
addEventOnOrderedRBTMap(analyzer, float(event['danceability']), event,
'danceability')
addEventOnOrderedRBTMap(analyzer, float(event['valence']), event,
'valence')
addEventOnOrderedRBTMap(analyzer, float(event['tempo']), event, 'tempo')
addTimedEvent(analyzer, event['created_at'], event, 'created_at')
def Actualizar_entrada(trip, datentry):
taxis = datentry["taxis"]
existtaxi = m.get(taxis, trip["taxi_id"])
if existtaxi is None:
taxidata = lt.newList("ARRAY_LIST")
if trip["trip_miles"] == "":
lt.addLast(taxidata, 0)
else:
lt.addLast(taxidata, float(trip["trip_miles"]))
if trip["trip_total"] == "":
lt.addLast(taxidata, 0)
else:
lt.addLast(taxidata, float(trip["trip_total"]))
lt.addLast(taxidata, 1)
m.put(taxis, trip["taxi_id"], taxidata)
else:
entry = existtaxi["value"]
if trip["trip_miles"] != "":
entry["elements"][0] += float(trip["trip_miles"])
if trip["trip_total"] != "":
entry["elements"][1] += float(trip["trip_total"])
entry["elements"][2] += 1
return datentry
def insert(iheap, key, index):
"""
Inserta la llave key con prioridad index
Args:
iheap: El heap indexado
Returns:
El iheap con la nueva paraja indexada
Raises:
Exception
"""
try:
if not map.contains(iheap['qpMap'], key):
iheap['size'] += 1
lt.insertElement(iheap['elements'], {
'key': key,
'index': index
}, iheap['size'])
map.put(iheap['qpMap'], key, iheap['size'])
swim(iheap, iheap['size'])
return iheap
except Exception as exp:
error.reraise(exp, 'indexheap:newindexheap')
def addGenre(catalog, genreName, movie):
genres = catalog["genres"]
exists = mp.contains(genres, genreName)
if exists:
entry = mp.get(genres, genreName)
genre = me.getValue(entry)
lt.addLast(genre["movies"], movie)
else:
genre = newGenre(genreName)
mp.put(genres, genreName, genre)
lt.addLast(genre["movies"], movie)
genreAvg = genre['vote_count']
movieAvg = movie['vote_count']
if (genreAvg == 0.0):
genre['vote_count'] = float(movieAvg)
else:
genre['vote_count'] = (genreAvg + float(movieAvg)) / 2
def addMovieProductionCompany(catalog, companyName, movie):
companies = catalog["productionCompanies"]
exists = mp.contains(companies, companyName)
if exists:
entry = mp.get(companies, companyName)
productionCompany = me.getValue(entry)
lt.addLast(productionCompany["movies"], movie)
else:
productionCompany = newProductionCompany(companyName)
mp.put(companies, companyName, productionCompany)
lt.addLast(productionCompany["movies"], movie)
companyAvg = productionCompany['vote_average']
movieAvg = movie['vote_average']
if (companyAvg == 0.0):
productionCompany['vote_average'] = float(movieAvg)
else:
productionCompany['vote_average'] = (companyAvg + float(movieAvg)) / 2
def studyMusic(maps, keylo1, keyhi1, keylo2, keyhi2):
'''
Recorre en los index de instrumentalness y tempo buscando las
opciones dentro del rango que busca el usuario
'''
caract1 = 'instrumentalness'
caract2 = 'tempo'
easylist = studyMap(maps, keylo1, keyhi1, keylo2, keyhi2, caract1, caract2)
if easylist is None:
return 0
else:
tracksMap = mp.newMap(34500, maptype='PROBING', loadfactor=0.5)
iterator = ite.newIterator(easylist)
while ite.hasNext(iterator):
events = ite.next(iterator)
mp.put(tracksMap, events['track_id'], events)
size = lt.size(tracksMap)
if size > 5:
tracklist = 0
else:
lista = mp.valueSet(tracksMap)
tracklist = get5artists(tracksMap, lista, size)
return size, tracklist
