def newAnalyzer():
""" Inicializa el analizador
Crea una lista vacia para guardar todos los crimenes
Se crean indices (Maps) por los siguientes criterios:
-Fechas
Retorna el analizador inicializado.
"""
analyzer = {'accidents': None,
'dateIndex': None,
'hoursIndex': None
}
analyzer['accidents'] = lt.newList('SINGLE_LINKED', compareIds)
analyzer['dateIndex'] = om.newMap(omaptype='RBT',
comparefunction=compareDates)
analyzer['hoursIndex'] = om.newMap(omaptype='RBT',
comparefunction=compareDates)
return analyzer
def thirdReq(catalog, category):
"""
Completa el requerimiento #3
"""
for cate in catalog["categories"]["table"]["elements"]:
try:
if int(cate["key"]) == int(category):
info = cate["value"]["videos"]
break
except:
pass
new_map = mp.newMap(50000, 50007, 'PROBING', 0.80, None)
i = 1
t = lt.size(info)
x = 0
while i <= t:
elem = lt.getElement(info, i)
value = {
"title": elem["title"],
"channel": elem["channel_title"],
"count": 1
}
key = elem["title"]
exists = mp.contains(new_map, key)
if not exists:
mp.put(new_map, key, value)
else:
new_value = mp.get(new_map, key)
key = elem["title"]
new_value["value"]["count"] += 1
mp.put(new_map, key, new_value["value"])
i += 1
new_list = lt.newList()
for element in new_map["table"]["elements"]:
if element["key"] != None:
lt.addLast(new_list, element["value"])
sorted_list = quick.sort(new_list, cmpVideosByTrendingdays)
result = lt.firstElement(sorted_list)
result["cat"] = category
return result
def newCatalog():
catalog = {
'sentimentvalues': None,
'events': None,
'content_cateogires': None,
'user_created_at': None
}
catalog['events'] = lt.newList('SINGLE_LINKED', cmpEvents)
catalog['sentimentvalues'] = mp.newMap(numelements=100000,
maptype='PROBING',
loadfactor=0.5,
comparefunction=cmpHashtags)
catalog['content_cateogries'] = mp.newMap(numelements=17,
maptype='PROBING',
loadfactor=0.5,
comparefunction=cmpCategories)
catalog['user_created_at'] = om.newMap(omaptype='RBT',
comparefunction=cmpDates)
catalog['unique_artists'] = mp.newMap(numelements=50000,
maptype='CHAINING',
loadfactor=0.5,
comparefunction=cmpCategories)
catalog['unique_tracks'] = mp.newMap(numelements=50000,
maptype='CHAINING',
loadfactor=0.5,
comparefunction=cmpCategories)
catalog['genre_dictionary'] = mp.newMap(numelements=100,
maptype='PROBING',
loadfactor=0.5,
comparefunction=cmpCategories)
catalog['content_created_at'] = om.newMap(omaptype='RBT',
comparefunction=cmpDates)
# TODO: compare times
catalog['tracks_hashtag'] = mp.newMap(numelements=100000,
maptype='PROBING',
loadfactor=0.5,
comparefunction=cmpCategories)
catalog['content_time'] = om.newMap(omaptype='RBT',
comparefunction=cmpTimes)
catalog['user_times'] = om.newMap(omaptype='RBT', comparefunction=cmpTimes)
return catalog
def newCatalog():
catalog = { 'analisis': None,
'info': None,
'sentimientos': None,
'instrumentalness': None,
'liveness': None,
'speechiness': None,
'danceability': None,
'valence': None,
'loudness': None,
'tempo': None,
'acousticness': None,
'energy': None,
'tiempo': None,
'hashtag': None
}
catalog['analisis'] = lt.newList('SINGLE_LINKED', compareIds)
catalog['instrumentalness'] = om.newMap(omaptype='RBT',
comparefunction=compare)
catalog['liveness'] = om.newMap(omaptype='RBT',
comparefunction=compare)
catalog['speechiness'] = om.newMap(omaptype='RBT',
comparefunction=compare)
catalog['danceability'] = om.newMap(omaptype='RBT',
comparefunction=compare)
catalog['valence'] = om.newMap(omaptype='RBT',
comparefunction=compare)
catalog['tempo'] = om.newMap(omaptype='RBT',
comparefunction=compare)
catalog['acousticness'] = om.newMap(omaptype='RBT',
comparefunction=compare)
catalog['energy'] = om.newMap(omaptype='RBT',
comparefunction=compare)
catalog['tiempo'] = om.newMap(omaptype='RBT',
comparefunction=compare)
catalog['sentimientos']= mp.newMap(2000,
maptype = 'CHAINING',
loadfactor = 4.0,
comparefunction = comparesenti)
return catalog
def Requirement3(analyzer, country1, country2):
tracemalloc.start()
delta_time = -1.0
delta_memory = -1.0
start_time = getTime()
start_memory = getMemory()
capital1 = (mp.get(analyzer['countries_map'],
country1)['value'])['CapitalName']
capital2 = (mp.get(analyzer['countries_map'],
country2)['value'])['CapitalName']
analyzer['paths'] = djk.Dijkstra(
analyzer['connections_origin_destination'], capital1)
path = djk.pathTo(analyzer['paths'], capital2)
distance = djk.distTo(analyzer['paths'], capital2)
listKm = lt.newList('ARRAY_LIST')
iterator1 = it.newIterator(path)
while it.hasNext(iterator1):
component = it.next(iterator1)
vertexA = edge.either(component)
vertexB = edge.other(component, vertexA)
weight = edge.weight(component)
string = 'Ir ' + str(weight) + ' Km desde ' + vertexA + ' a ' + vertexB
lt.addLast(listKm, string)
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return (listKm, distance, delta_time, delta_memory)
def newCatalog():
catalog = {
'peliculas': None,
'productoras': None,
'directores': None,
'actores': None,
'generos': None,
'paises': None
}
catalog['peliculas'] = lt.newList('SINGLE_LINKED', compareIds)
catalog['id'] = mp.newMap(830000,
maptype='PROBING',
loadfactor=0.4,
comparefunction=compareIds)
catalog['idCast'] = mp.newMap(830000,
maptype='PROBING',
loadfactor=0.4,
comparefunction=compareIds)
catalog['productoras'] = mp.newMap(63000,
maptype='PROBING',
loadfactor=0.4,
comparefunction=compareProductoras)
catalog['directores'] = mp.newMap(214775,
maptype='PROBING',
loadfactor=0.4,
comparefunction=compareDirectores)
catalog['actores'] = mp.newMap(800000,
maptype='PROBING',
loadfactor=0.7,
comparefunction=compareActores)
catalog['generos'] = mp.newMap(40,
maptype='CHAINING',
loadfactor=0.7,
comparefunction=compareGeneros)
catalog['paises'] = mp.newMap(400,
maptype='CHAINING',
loadfactor=0.7,
comparefunction=comparePaises)
return catalog
def newCatalog(type_list='ARRAY_LIST'):
"""
Inicializa el catálogo de libros. Crea una lista vacia para guardar
todos los libros, adicionalmente, crea una lista vacia para los autores,
una lista vacia para los generos y una lista vacia para la asociación
generos y libros. Retorna el catalogo inicializado.
"""
if type_list != 'SINGLE_LINKED' and type_list != 'ARRAY_LIST':
print('Invalid type')
catalog = {
'videos': None,
'videoIDs': None,
'categories': None,
'categoryIDs': None,
'countries': None
}
catalog['countries'] = mp.newMap(200,
maptype='PROBING',
loadfactor=0.5,
comparefunction=compareCountriesByName)
catalog['videos'] = lt.newList(type_list, cmpvideoid)
catalog['videoIDs'] = mp.newMap(10000,
maptype='CHAINING',
loadfactor=4.0,
comparefunction=compareMapVideoIds)
catalog['categories'] = mp.newMap(34500,
maptype='PROBING',
loadfactor=0.5,
comparefunction=compareCategoryNames)
catalog['categoryIDs'] = mp.newMap(34500,
maptype='CHAINING',
loadfactor=4.0,
comparefunction=compareCategoryIds)
return catalog
def verificacion(mas_cables, analyzer, mayor):
mapa_lp = analyzer['info_lp']
lista_landing_points = mp.keySet(mapa_lp)
tamano_llp = lt.size(lista_landing_points)
lp_ret = lt.newList('ARRAY_LIST')
lt.addLast(lp_ret, mas_cables)
i = 0
while i < tamano_llp:
elemento = lt.getElement(lista_landing_points, i)
entry = mp.get(mapa_lp, elemento)
if entry != None:
minidic = me.getValue(entry)
mapa_cables = minidic['cables']
lista_cables = mp.keySet(mapa_cables)
cantidad_cables = lt.size(lista_cables)
if cantidad_cables == mayor:
if elemento != mas_cables:
lt.addLast(lp_ret, elemento)
i += 1
return lp_ret
def newCatalog():
catalog={"videos": None,
"videos-id": None,
"categorias": None,
"category-id": None,
"country": None}
catalog["videos"]=lt.newList(datastructure="ARRAY_LIST")
catalog["videos-id"]=mp.newMap(10000,
maptype="CHAINING",
loadfactor=4.0)
catalog["categorias"]=mp.newMap(37,
maptype="PROBING",
loadfactor=0.5)
catalog["category-id"]=mp.newMap(37,
maptype="CHAINING",
loadfactor=4.0)
catalog["country"]=mp.newMap(20,
maptype="PROBING",
loadfactor=0.5)
return catalog
def addMapMusicaFechas(catalog, musica):
"""
Reliza un RBT por fechas que contiene la musica en este periodo
"""
fecha = musica['created_at']
fecha = fecha[11:]
EstaKey = om.contains(catalog['fechaMusica'], fecha)
if not (EstaKey):
ArtistList = lt.newList('ARRAY_LIST')
om.put(catalog['fechaMusica'], fecha, ArtistList)
ListaArtistaEntry = om.get(catalog['fechaMusica'], fecha)
ListaArtista = me.getValue(ListaArtistaEntry)
lt.addLast(ListaArtista, musica)
om.put(catalog['fechaMusica'], fecha, ListaArtista)
else:
ListaArtistaEntry = om.get(catalog['fechaMusica'], fecha)
ListaArtista = me.getValue(ListaArtistaEntry)
lt.addLast(ListaArtista, musica)
om.put(catalog['fechaMusica'], fecha, ListaArtista)
def keys(bst, keylo, keyhi):
"""
Retorna todas las llaves del arbol que se encuentren entre
[keylo, keyhi]
Args:
bst: La tabla de simbolos
keylo: limite inferior
keylohi: limite superiorr
Returns:
Las llaves en el rago especificado
Raises:
Exception
"""
try:
lstkeys = lt.newList('SINGLE_LINKED', bst['cmpfunction'])
lstkeys = keysRange(bst['root'], keylo, keyhi, lstkeys,
bst['cmpfunction'])
return lstkeys
except Exception as exp:
error.reraise(exp, 'BST:keys')
def genresbytempo(num):
genres = lt.newList(datastructure="ARRAY_LIST")
if num >= 100 and num <= 160:
lt.addLast(genres, 'metal')
if num >= 110 and num <= 140:
lt.addLast(genres, 'rock')
if num >= 120 and num <= 125:
lt.addLast(genres, 'jazz and funk')
if num >= 100 and num <= 130:
lt.addLast(genres, 'pop')
if num >= 85 and num <= 115:
lt.addLast(genres, 'hip-hop')
if num >= 90 and num <= 120:
lt.addLast(genres, 'chill-out')
if num >= 70 and num <= 110:
lt.addLast(genres, 'down-tempo')
if num >= 60 and num <= 90:
lt.addLast(genres, 'reggae')
if num >= 60 and num <= 80:
lt.addLast(genres, 'r&b')
return genres
def getMoviesByCompany(catalog, companyName):
catalogCompany = mp.get(catalog["production_company"], companyName)
if catalogCompany:
companyData = me.getValue(catalogCompany)
moviesNum = lt.size(companyData)
companyAvg = 0.00
companyMovies = lt.newList(PARAMS["listtype"])
for i in range(moviesNum):
movie = getMovie(catalog, lt.getElement(companyData, i))
lt.addLast(companyMovies, movie)
companyAvg += float(movie["vote_average"])
companyAvg = round(companyAvg/moviesNum, 2)
return (companyMovies,moviesNum,companyAvg)
return (None, None, None)
def addGenre(map, element):
generos = element['genres'].split('|')
for i in range(len(generos)):
genero = generos[i]
existgenero = mp.contains(map, genero)
mov = {}
if existgenero:
value = me.getValue(mp.get(map, genero))
value['vote'] = prom(value['vote'], element['vote_count'])
value['avg'] = prom(value['avg'], element['vote_average'])
value['size'] = int(value['size']) + 1
añadirAlFinal(value['table'], element)
else:
lst = lt.newList('SINGLE_LINKED', compareElements)
añadirAlFinal(lst, element)
mov['vote'] = prom(0.0, element['vote_count'])
mov['avg'] = prom(0.0, element['vote_average'])
mov['size'] = 1
mov['table'] = lst
addMap(map, genero, mov)
def requerimiento2(analyzer):
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
lstcables = model.servedCables(analyzer)
result = lt.newList()
for cable in lt.iterator(lstcables[0]):
lt.addLast(result, model.selectResult(cable, 'cable'))
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return ((result, lstcables[1]), (delta_time, delta_memory))
def partyMusic(catalog, min_energy, max_energy, min_danceability,
max_danceablity):
energy_tree = me.getValue(mp.get(catalog['content_cateogries'], 'energy'))
energy_values = om.values(energy_tree, min_energy, max_energy)
unique_tracks = mp.newMap(numelements=5000,
maptype='CHAINING',
comparefunction=cmpCategories)
final_items = lt.newList(datastructure='ARRAY_LIST')
for sublist in lt.iterator(energy_values):
for event in lt.iterator(sublist):
if checkWithUser(catalog, event):
if min_danceability <= float(
event['danceability']) <= max_danceablity:
lt.addLast(final_items, event)
mp.put(unique_tracks, event['track_id'], event)
tracks = mp.size(unique_tracks)
return final_items, tracks
def top_companies_by_services(catalog, top_number):
companies_per_services = catalog["companies"]["companies_per_services"]
key_lst = m.keySet(companies_per_services)
greater = 0
counter = 0
lst = lt.newList(cmpfunction=compare_companies)
while counter < top_number:
iterator = it.newIterator(key_lst)
while it.hasNext(iterator):
company = it.next(iterator)
entry = m.get(companies_per_services, company)
services_number = me.getValue(entry)
if services_number > greater:
greater = services_number
greater_company = company
lt.addLast(lst, (greater_company, greater))
pos = lt.isPresent(key_lst, greater_company)
lt.deleteElement(key_lst, pos)
greater = 0
counter += 1
return lst
def addCategoryAndCountry(catalog, video):
"""
Para el req 1, en un mapa añade llaves que son la union de una categoria y un pais y como valor guarda una lista de videos
"""
existsCategoryAndCountry = mp.contains(
catalog['categoriesAndCountries'],
(video['category_id'] + video['country'].lower().strip()))
if existsCategoryAndCountry:
existing = mp.get(
catalog['categoriesAndCountries'],
(video['category_id'] + video['country'].lower().strip()))
existingList = me.getValue(existing)
lt.addLast(existingList, video)
else:
lists = lt.newList('ARRAY_LIST')
lt.addFirst(lists, video)
mp.put(catalog['categoriesAndCountries'],
(video['category_id'] + video['country'].lower().strip()),
lists)
def Add_actor(catalog, row):
lista_actores = catalog["actores"]
for num_actor in range(1, 6):
actor = "actor{num}_name".format(num=num_actor)
nombre_actor = row[actor]
existe = mp.contains(lista_actores, nombre_actor)
if not existe:
lista_ids = lt.newList('ARRAY_LIST')
lt.addLast(lista_ids, row["id"])
colaboraciones = {}
colaboraciones[row["director_name"]] = 1
informacion_actor = [lista_ids, colaboraciones]
mp.put(lista_actores, nombre_actor, informacion_actor)
elif existe:
llave_valor = mp.get(lista_actores, nombre_actor)
valor = me.getValue(llave_valor)
lt.addLast(valor[0], row["id"])
if row["director_name"] in valor[1]:
valor[1][row["director_name"]] += 1
elif not row["director_name"] in valor[1]:
valor[1][row["director_name"]] = 1
def locateLPs(catalog, lst_lps):
lst_affected_countries = lt.newList(datastructure='ARRAY_LIST')
# Para todos los LPs que son adj:
for lp in lt.iterator(lst_lps):
lp = lp[0]
notFound = True
i = 1
cables = mp.keySet(
mp.get(catalog['landingpoints'], lp)['value']['lstcables'])
# Busca los cables que sean 'Land Cable' (estos son los conecta un LP con la capital (si la hay))
while notFound and i < lt.size(cables):
cable = lt.getElement(cables, i)
if 'Land Cable' in cable:
capital = cable.split('-')[1:][0]
country = mp.get(catalog['capitals'], capital)['value']
if not (lt.isPresent(lst_affected_countries, country)):
lt.addLast(lst_affected_countries, country)
notFound = False
# Cuando ya la haya encontrado se acaba el ciclo
i += 1
return lst_affected_countries
def sublistByTags(lista, tag, top):
size = lt.size(lista)
sublist = lt.newList('ARRAY_LIST')
tag = tag.lower()
i = 0
T = 0
while i < size:
video = lt.getElement(lista, i)
tag1 = video['tags'].lower()
if tag in tag1:
lt.addLast(sublist, video)
T += 1
if T == int(top):
break
i += 1
return sublist
def Req4(catalog,country,tag):
videosCountry= getVideosByCountry(catalog, country)
result=lt.newList('ARRAY_LIST',compareLikes)
b=lit.newIterator(videosCountry['videos'])
while lit.hasNext(b):
e=lit.next(b)
if tag in e['tags']:
dic={}
r= lt.isPresent(result,e)
if r==0:
dic['title']=e['title']
dic['channel_title']=e['channel_title']
dic['publish_time']=e['publish_time']
dic['views']=e['views']
dic['likes']=e['likes']
dic['dislikes']=e['dislikes']
dic['tags']=e['tags']
lt.addLast(result,dic)
sort=sortLikes(result)
#print(lt.getElement(dic_sort,1))
return sort
def isEmpty(map):
""" Informa si la tabla de hash se encuentra vacia
Args:
map: El map
Returns:
True: El map esta vacio
False: El map no esta vacio
Raises:
Exception
"""
try:
bucket = lt.newList()
empty = True
for pos in range(lt.size(map['table'])):
bucket = lt.getElement(map['table'], pos + 1)
if lt.isEmpty(bucket) is False:
empty = False
break
return empty
except Exception as exp:
error.reraise(exp, 'Chain:isempty')
def newHeap(cmpfunction):
"""
Crea un nuevo heap basado en un arreglo, cuyo primer elemento
es inicializado en None y no será utilizado
Args:
cmpfunction: La funcion de comparacion
size: El numero de elementos
Returns:
El heap
Raises:
Exception
"""
try:
heap = {'elements': None, 'size': 0, 'cmpfunction': cmpfunction}
heap['elements'] = lt.newList(datastructure='ARRAY_LIST',
cmpfunction=cmpfunction)
return heap
except Exception as exp:
error.reraise(exp, 'newHeap')
def countByGender(map, minT, maxT, gender):
lst = om.values(map, minT, maxT)
size1 = lt.size(lst)
lst1 = lt.newList('ARRAY_LIST')
songs = 0
i = 0
while i < size1:
val = lt.getElement(lst, i)
size2 = lt.size(val['lstsongs'])
songs += size2
j = 0
while j < size2:
sub = lt.getElement(val['lstsongs'], j)
lt.addLast(lst1, sub)
j += 1
i += 1
return {'gender': gender, 'songs': lst1, 'count': songs}
def addMovieByCountry(catalog, countryName, movie):
countries = catalog['countries']
existcountry = mp.contains(countries, countryName)
country = None
if existcountry:
entry = mp.get(countries, countryName)
country = me.getValue(entry)
else:
country = {
'name': countryName,
'movies': lt.newList('ARRAY_LIST', compareCountry),
'votes': 0.0,
'vote_average': 0.0,
'vote_count': 0
}
mp.put(countries, countryName, country)
lt.addLast(country['movies'], movie)
country['votes'] += float(movie['vote_average'])
country['vote_average'] = country['votes'] / float(
country['movies']['size'])
country['vote_count'] += int(movie['vote_count'])
def values(rbt, keylo, keyhi):
"""
Retorna todas los valores del arbol que se encuentren entre
[keylo, keyhi]
Args:
bst: La tabla de simbolos
keylo: limite inferior
keylohi: limite superiorr
Returns:
Las llaves en el rago especificado
Raises:
Exception
"""
try:
lstvalues = lt.newList('SINGLELINKED', rbt['cmpfunction'])
lstvalues = valuesRange(rbt['root'], keylo, keyhi, lstvalues,
rbt['cmpfunction'])
return lstvalues
except Exception as exp:
error.reraise(exp, 'RBT:Values')
def requerimiento1(catalog, size, tipodeorden, categ, pais, tipo):
nueva = lt.newList(tipo)
for i in range(0, lt.size(catalog['videos'])):
ele = lt.getElement(catalog['videos'], i)
if ele['category_id'] == categ and ele['country'] == pais:
lt.addLast(nueva, ele)
sublista = nueva.copy()
start_time = time.process_time()
if (tipodeorden == "shell"):
sorted_list = sa.sort(sublista, cmpVideosByViews)
elif (tipodeorden == "insertion"):
sorted_list = si.sort(sublista, cmpVideosByViews)
elif (tipodeorden == "selection"):
sorted_list = ss.sort(sublista, cmpVideosByViews)
elif (tipodeorden == "quick"):
sorted_list = sq.sort(sublista, cmpVideosByViews)
elif (tipodeorden == "merge"):
sorted_list = sm.sort(sublista, cmpVideosByViews)
stop_time = time.process_time()
elapsed_time_mseg = (stop_time - start_time) * 1000
return elapsed_time_mseg, sorted_list
def getMoviesByActor(catalog, actorn):
"""
Retorna un autor con sus peliculas a partir del nombre del actor
"""
actor = mp.get(catalog["actor"], actorn)
if actor:
actorData = me.getValue(actor)
actorAvg = actorData['vote_average']
actorMovies = lt.newList(info["listtype"])
for i in range(lt.size(actorData["movies"])):
movie = lt.getElement(actorData["movies"], i)
lt.addLast(actorMovies, movie)
mostDir = actorData['director']
comun = []
for i in range(lt.size(actorData['director'])):
comun.append(lt.getElement(actorData['director'], i))
actorDir = max(set(comun), key=comun.count)
return (actorMovies, actorDir, actorAvg)
return (None, None)
def reqBpart2(analyzer, M, fecha1, fecha2):
mp = {}
for key, value in travel_map(analyzer["taxis"]):
has = False
for i in value["dates"]:
if fecha1 <= i <= fecha2:
has = True
if has and value["money"] != 0:
puntos = value["miles"] / value["money"]
mp[key] = puntos
final = lt.newList("ARRAY_LIST")
if mp == {}:
return final
while final["size"] < M:
mayor = 0
for i in mp:
if mp[i] > mayor and i not in final['elements']:
mayor = mp[i]
bestkey = i
lt.addLast(final, bestkey)
return final
