def distTo(search, vertex):
"""
Retorna el costo para llegar del vertice
source al vertice vertex.
Args:
search: La estructura de busqueda
vertex: El vertice destino
Returns:
El costo total para llegar de source a
vertex. Infinito si no existe camino
Raises:
Exception
"""
try:
visited_v = map.get(search['visited'], vertex)
if visited_v is None:
return math.inf
return visited_v['value']['distTo']
except Exception as exp:
error.reraise(exp, 'dks:disto')
def addCategoryids(catalog, video):
"""
Adiciona un video a la lista de videos de una categoría específica,
las categorías se guardan en un map, donde la llave es el id de la
categoría y el valor es la lista de videos de esa categoría
"""
try:
categoryids = catalog['categoryids']
videoCategoryid = video['category_id']
existcategoryid = mp.contains(categoryids, videoCategoryid)
if existcategoryid:
entry = mp.get(categoryids, videoCategoryid)
categoryid = me.getValue(entry)
else:
categoryid = newVideoCategory(videoCategoryid)
mp.put(categoryids, videoCategoryid, categoryid)
lt.addLast(categoryid['videos'], video)
categoryid['total_videos'] = lt.size(categoryid['videos'])
except Exception:
return None
def PrimMST(graph):
"""
Implementa el algoritmo de Prim
Args:
graph: El grafo de busqueda
Returns:
La estructura search con los MST
Raises:
Exception
"""
try:
search = initSearch(graph)
vertices = g.vertices(graph)
for vert in lt.iterator(vertices):
if not map.get(search['marked'], vert)['value']:
prim(graph, search, vert)
return search
except Exception as exp:
error.reraise(exp, 'prim:PrimMST')
def getVideosByCountryAndTag(catalog, countryname, tag):
"""
Retornar la lista de videos asociados a una categoria y un tag
"""
tag = tag.lower() # make lowercase
new_catalog = initCatalog()
country = mp.get(catalog['countries'], countryname)
tagexists = False
if country:
videos = me.getValue(country)['videos']
for vid_i in lt.iterator(videos):
vid_i_tags = vid_i['tags'].replace('"',
'').lower() # make lowercase
vid_i_tags = vid_i_tags.split("|")
for tag_kw in vid_i_tags: # compare with specified tag
if tag in tag_kw.split():
tagexists = True
if tagexists:
addVideo(new_catalog, vid_i)
return new_catalog
def adjacentEdges(graph, vertex):
"""
Retorna una lista con todos los arcos asociados a los vértices
adyacentes de vertex
Args:
graph: El grafo sobre el que se ejecuta la operacion
vertex: El vertice del que se quiere la lista
Returns:
La lista de arcos adyacentes
Raises:
Exception
"""
try:
element = map.get(graph['vertices'], vertex)
lst = element['value']
return lst
except Exception as exp:
error.reraise(exp, 'ajlist:adjacentEdges')
def LandingPointNN(analyzer, lp_vertex):
'''
Calcula los landing points vecinos
'''
adj_edges = gr.adjacentEdges(analyzer['connections'], lp_vertex)
info_out = {} # save info of each landing point
vert_dist = {}
for edge_ in lt.iterator(adj_edges):
nb = edge_['vertexB']
nb_id = int(nb.split('*')[0])
lp_info = m.get(analyzer['landing_points'], nb_id)['value']
info_out[edge_['vertexB']] = {
'name': lp_info['name'],
'dist': edge_['weight'],
'id': nb_id
}
vert_dist[edge_['vertexB']] = edge_['weight']
# sort_dist = sorted(vert_dist.items(), key=lambda x:x[1], reverse=True)
return adj_edges, vert_dist, info_out
def addPais(diccio):
iterador = it.newIterator(diccio["videos"])
while it.hasNext(iterador):
actual = it.next(iterador)
if mp.contains(diccio["trending"], actual["country"]) == True:
par = mp.get(diccio['trending'], actual["country"])
lis = me.getValue(par)
lt.addLast(lis, actual)
else:
lis = lt.newList()
mp.put(diccio['trending'], actual["country"], lis)
lt.addLast(lis, actual)
return diccio
def indegree(graph, vertex):
"""
Retorna el numero de arcos que llegan al vertice vertex
Args:
graph: El grafo sobre el que se ejecuta la operacion
vertex: El vertice del que se desea conocer el grado
Returns:
El grado del vertice
Raises:
Exception
"""
try:
if (graph['directed']):
degree = map.get(graph['indegree'], vertex)
return degree['value']
return 0
except Exception as exp:
error.reraise(exp, 'ajlist:indegree')
def getSeverityByTime(dataBase, timeLo, timeHi):
timeLo = datetime.datetime.strptime(timeLo, '%H:%M:%S').time()
timeHi = datetime.datetime.strptime(timeHi, '%H:%M:%S').time()
print(timeLo)
data = model.getSeverityByTime(dataBase, timeLo, timeHi)
index = m.keySet(data['severityIndex'])
count = lt.size(index)
result = lt.newList()
lt.addLast(result, data['size'])
while count > 0:
count -= 1
key = lt.removeFirst(index)
if key is not None:
num = m.get(data['severityIndex'], key)
num = me.getValue(num)
lt.addLast(result, (key, num))
return result
def req_6(self, server, cable):
respuesta = lt.newList('ARRAY_LIST')
bandwith, countries, index = mp.get(self.cable_bandwith,
cable)['value']
graphing = graphing_helper(self)
graphing.graph_cable_line(index)
country_it = ll_it.newIterator(countries)
has_server = False
while ll_it.hasNext(country_it):
country = ll_it.next(country_it)
if country != server:
users = self.get_internet_users(country)
guaranteed = round(bandwith * 1000000 / users, 3)
lt.addLast(respuesta, (country, guaranteed))
else:
has_server = True
graphing.graph_capacities(respuesta)
respuesta = "\n".join(
["{}: {} Mbps".format(*args) for args in respuesta['elements']])
return respuesta, has_server
def addCompany(movie,catalog):
"""
Agrega una nueva compañia al mapa de productoras
"""
companies=catalog['production_companies']
company_name=movie['production_companies']
exist=mp.contains(companies, company_name)
if exist:
entry=mp.get(companies, company_name)
company=me.getValue(entry)
else:
company=newComopanies(company_name)
mp.put(companies, company_name, company)
lt.addLast(company['movies'], movie)
avg_cp=company['vote_avg']
avg_mv=movie['vote_average']
if avg_cp == None:
company['vote_avg']=float(avg_mv)
else:
company['vote_avg']= round(((avg_cp+ float(avg_mv))/2),2)
def requerimiento3(catalog, categor):
final = None
nueva = lt.newList("ARRAY_LIST")
listaesta = {}
cates = mp.get(catalog['categoriasid'], categor)
if cates:
cavideos = me.getValue(cates)['videos']
for v in lt.iterator(cavideos):
if not(v['title'] in listaesta.keys()):
listaesta[v['title']] = 1
v['dias'] = 1
lt.addLast(nueva, v)
elif (v['title'] in listaesta.keys()):
listaesta[v['title']] = listaesta[v['title']]+1
v['dias'] = listaesta[v['title']]
lt.addLast(nueva, v)
sublista = nueva.copy()
sorted_list = sa.sort(sublista, cmpVideosBytiempo)
final = lt.subList(sorted_list, 1, 1)
return final
def requerimiento2(catalog,pais):
final = None
nueva = lt.newList("ARRAY_LIST")
listaesta = {}
paisess = mp.get(catalog['pais'], pais.strip())
if paisess:
pavideos = me.getValue(paisess)['videos']
for v in lt.iterator(pavideos):
if not(v['title'] in listaesta.keys()):
listaesta[v['title']] = 1
v['dias'] = 1
lt.addLast(nueva, v)
elif (v['title'] in listaesta.keys()):
listaesta[v['title']] = listaesta[v['title']]+1
v['dias'] = listaesta[v['title']]
lt.addLast(nueva, v)
sublista = nueva.copy()
sorted_list = sa.sort(sublista, cmpVideosBytiempo)
final = lt.subList(sorted_list, 1, 1)
return final
def requerimiento1(analyzer, origin, destination):
delta_time = -1.0
delta_memory = -1.0
tracemalloc.start()
start_time = getTime()
start_memory = getMemory()
landingpoints = mp.keySet(analyzer['landingpoints'])
capitals = mp.keySet(analyzer['countrypoints'])
capital = False
vertexa = None
vertexb = None
for key in lt.iterator(capitals):
if origin in key:
vertexa = key
if destination in key:
vertexb = key
if vertexa is not None and vertexb is not None:
capital = True
if not capital:
for key in lt.iterator(landingpoints):
dataentry = mp.get(analyzer['landingpoints'], key)
entry = me.getValue(dataentry)
if not vertexa and origin in entry['data']['name']:
key = lt.firstElement(entry['points'])
vertexa = key
if not vertexb and destination in entry['data']['name']:
key = lt.firstElement(entry['points'])
vertexb = key
clusters = model.connectedComponents(analyzer)
samecluster = model.sameCluster(analyzer, vertexa, vertexb)
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return ((clusters, samecluster), (delta_time, delta_memory))
def addDate(analyzer, actual):
date = getDateTimeTaxiTrip(actual['trip_start_timestamp'])[0]
current = om.get(analyzer['datesByTaxis'], date)
if current is None:
mapa = m.newMap(comparefunction=compareDatesValues)
om.put(analyzer['datesByTaxis'], date, mapa)
current = om.get(analyzer['datesByTaxis'], date)['value']
money = float(actual['trip_total'])
millas = float(actual['trip_miles'])
if money > 0:
puntos = millas / money
else:
puntos = 0
m.put(current, actual['taxi_id'], [money, millas, 1, puntos])
else:
value = m.get(current['value'], actual['taxi_id'])
if actual['trip_total'] != '':
money = float(actual['trip_total'])
else:
money = 0
if actual['trip_miles'] != '':
millas = float(actual['trip_miles'])
else:
millas = 0
if value is None:
if money > 0:
puntos = millas / money
else:
puntos = 0
m.put(current['value'], actual['taxi_id'],
[money, millas, 1, puntos])
else:
money = value['value'][0] + money
millas = value['value'][1] + millas
total = value['value'][2] + 1
if money > 0:
puntos = (millas / money) * total
else:
puntos = 0
m.put(current['value'], actual['taxi_id'],
[money, millas, total, puntos])
def printReq2(analyzer, lista_ordenada):
posicion = 1
numeros = '0123456789'
if lt.getElement(lista_ordenada, posicion)['size'] != lt.getElement(
lista_ordenada, posicion + 1)['size']:
vertice = lt.getElement(lista_ordenada, posicion)
if vertice['vertice'][0] not in numeros:
pais = vertice['vertice'].split('-')[
1] # llaves son vertice y size
print("\nNombre/ID: {0} | País: {1} | Arcos:{2}\n".format(
vertice['vertice'], pais, vertice['size']))
else:
while posicion < lt.size(lista_ordenada) and lt.getElement(
lista_ordenada, posicion)['size'] == lt.getElement(
lista_ordenada, posicion + 1)['size']:
verticeDict = lt.getElement(lista_ordenada,
posicion) # llaves son vertice y size
id_unique = ''
indice = 0
while verticeDict['vertice'][indice] in numeros:
id_unique = id_unique + verticeDict['vertice'][indice]
indice += 1
pais = mp.get(analyzer['infoLandingPoints'],
id_unique)['value']['name'].split(', ')[1]
print("\nNombre: {0} | País: {1} | ID: {2} | Arcos:{3}\n".format(
verticeDict['vertice'], pais, id_unique, verticeDict['size']))
posicion += 1
return vertice
def addDirector(catalog, movie, details):
companies = catalog["director_name"]
movieId = movie["id"]
name = movie["director_name"]
existauthor = mp.contains(companies, name)
if existauthor:
entry = mp.get(companies, name)
company = me.getValue(entry)
else:
company = newDirector()
mp.put(companies, name, company)
lt.addLast(company['movies'], details['original_title'])
companyAvg = company["vote_average"]
movieAvg = details["vote_average"]
if (movieAvg == 0.0):
company["vote_average"] = float(movieAvg)
else:
moviesNum = lt.size(company["movies"])
company["vote_average"] = (
(companyAvg * (moviesNum - 1)) + float(movieAvg)) / moviesNum
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 addDateIndex(datentry, accident):
"""
Actualiza un indice de tipo de crimenes. Este indice tiene una lista
de crimenes y una tabla de hash cuya llave es el tipo de crimen y
el valor es una lista con los crimenes de dicho tipo en la fecha que
se está consultando (dada por el nodo del arbol)
"""
lst = datentry['lstaccidents']
lt.addLast(lst, accident)
SeverityIndex = datentry['SeverityIndex']
sevntry = m.get(SeverityIndex, accident['Severity'])
if (sevntry is None):
entry = newSeverityEntry(accident['Severity'], accident)
lt.addLast(entry['lstSeverity'], accident)
m.put(SeverityIndex, accident['Severity'], entry)
else:
entry = me.getValue(sevntry)
lt.addLast(entry['lstSeverity'], accident)
return datentry
def printReq4(list, analyzer):
"""
Hace print de el requerimiento 4
"""
for genre in list:
res = controller.filterByGenre(analyzer, genre)
keys = mp.keySet(res[1])
entry = mp.get(analyzer["genre_intervals"], genre)
value = me.getValue(entry)
print("\n========" + genre + "========")
print("For " + genre + " the tempo is between " + str(value[0]) +
" and " + str(value[1]))
print(genre + " reproductions: " + str(res[2]) + " Unique Artists: " +
str(res[0]))
size = mp.size(res[1])
pos = 0
while pos <= 10:
randomNum = randint(1, size)
ranElement = lt.getElement(keys, randomNum)
print("Track " + str(pos) + ": " + ranElement)
pos += 1
def addProductionCompanie(catalog, production_companie_name, 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
"""
existproduction_companies = mp.contains(catalog['production_companies'],
production_companie_name)
if existproduction_companies:
entry = mp.get(catalog['production_companies'],
production_companie_name)
companie = me.getValue(entry)
else:
companie = newProductionCompanie(production_companie_name)
mp.put(catalog['production_companies'], production_companie_name,
companie)
lt.addLast(companie['movies'], movie)
totmovies = lt.size(companie["movies"])
movie_average = 0
companie["vote_average"] += float(movie["vote_average"])
def musicForPartyingOrStudying(analyzer, option1, option2, iValue1, fValue1,
iValue2, fValue2):
"""
Tiene como return el numero de tracks unicos y un map con
el track id como llaves
"""
values = om.values(analyzer[option1], iValue1, fValue1)
storageMap = mp.newMap(maptype="PROBING")
for track in lt.iterator(values):
for uniqueEvent in lt.iterator(track):
if float(uniqueEvent[option2]) >= iValue2 and float(
uniqueEvent[option2]) <= fValue2:
trackKey = uniqueEvent["track_id"]
optionEntry = mp.get(storageMap, trackKey)
if optionEntry is None:
optionEntry = newDataEntry(uniqueEvent)
mp.put(storageMap, trackKey, optionEntry)
else:
optionEntry = me.getValue(optionEntry)
lt.addLast(optionEntry, uniqueEvent)
return mp.size(storageMap), storageMap
def addMovieActor(catalog, actorname, movie):
actors = catalog['Actores']
existactor = mp.contains(actors, actorname)
if existactor:
entry = mp.get(actors, actorname)
Actor = me.getValue(entry)
else:
Actor = newActor(actorname)
mp.put(actors, actorname, Actor)
lt.addLast(Actor['movie'], movie)
actoravg = Actor['average_rating']
movieavg = movie['vote_average']
numbermov = Actor['number_movies']
if (actoravg == 0.0):
Actor['average_rating'] = float(movieavg)
else:
Actor['average_rating'] = (
(actoravg * numbermov) + float(movieavg)) / (numbermov + 1)
Actor['number_movies'] += 1
def addSeverityToDateEntry(date_entry,accident):
"""
RETO3 - REQ1
Actualiza un indice de grado de severidad. Este indice tiene una lista
de accidentes y una tabla de hash cuya llave es el grado de severidad del
accidente y el valor es una lista con los accidentes de dicha severidad
en la fecha que se está consultando (dada por el nodo del arbol)
"""
lt.addLast(date_entry['Accidents_lst'],accident)
severity = accident['Severity']
entry = m.get(date_entry['Severities_mp'], severity)
if entry is None:
severity_entry = newSeverityEntry(accident)
lt.addLast(severity_entry['ListBySeverity'],accident)
m.put(date_entry['Severities_mp'] , severity, severity_entry)
else:
severity_entry = me.getValue(entry)
lt.addLast(severity_entry['ListBySeverity'],accident)
return date_entry
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 addMovieByProductionCompany(catalog, companyName, movie):
companies = catalog['productionCompanies']
existcompany = mp.contains(companies, companyName)
if existcompany:
entry = mp.get(companies, companyName)
company = me.getValue(entry)
else:
company = NewProductionCompany(companyName)
mp.put(companies, companyName, company)
lt.addLast(company['movies'], movie)
companyavg = company['vote_average']
movieavg = movie['vote_average']
if (companyavg[0] == 0.0):
company['vote_average'][0] = float(movieavg)
company['vote_average'][1] = float(movieavg)
company['vote_average'][2] = 1
else:
company['vote_average'][1] = companyavg[1] + float(movieavg)
company['vote_average'][2] += 1
company['vote_average'][
0] = company['vote_average'][1] / company['vote_average'][2]
def addMoviesByCountry(catalog, movie, country):
paises = catalog["country"]
checkCountry = mp.contains(paises, country)
if checkCountry:
entry = mp.get(paises, country)
pais_movie = me.getValue(entry)
else:
pais_movie = newGenre(country)
mp.put(paises, country, pais_movie)
lt.addLast(pais_movie['genres'], movie)
promedio_peli = float(movie["vote_average"])
if pais_movie["vote_average"][0] == 0.0:
pais_movie["vote_average"][0] = promedio_peli
pais_movie["cantidad"] = 1
else:
pais_movie["vote_average"][
0] = pais_movie["vote_average"][0] + promedio_peli
pais_movie["cantidad"] += 1
pais_movie["vote_average"][
1] = pais_movie["vote_average"][0] / pais_movie["vote_average"]
def addCountry(catalogo, movie):
companies = catalogo["production_countries"]
movieId = movie["id"]
name = movie["production_countries"]
existauthor = mp.contains(companies, name)
if existauthor:
entry = mp.get(companies, name)
company = me.getValue(entry)
else:
company = newCountry()
mp.put(companies, name, company)
lt.addLast(company['movies'], movieId)
companyAvg = company["vote_average"]
movieAvg = movie["vote_average"]
if (movieAvg == 0.0):
company["vote_average"] = float(movieAvg)
else:
moviesNum = lt.size(company["movies"])
company["vote_average"] = (
(companyAvg * (moviesNum - 1)) + float(movieAvg)) / moviesNum
def outdegree(graph, vertex):
"""
Retorna el numero de arcos que salen del grafo vertex
Args:
graph: El grafo sobre el que se ejecuta la operacion
vertex: El vertice del que se desea conocer el grado
Returns:
El grado del vertice
Raises:
Exception
"""
try:
if (graph['directed']):
element = map.get(graph['vertices'], vertex)
lst = element['value']
return (lt.size(lst))
return 0
except Exception as exp:
error.reraise(exp, 'ajlist:outdegree')
def getCloserStation(analyzer, latitud, longitud):
grafo = analyzer['graph']
vertice = str(72)
recorrido = m.keySet(dfs.DepthFirstSearch(grafo, vertice)['visited'])
iterator = it.newIterator(recorrido)
distance = float('inf')
closer = 0
while it.hasNext(iterator):
element = it.next(iterator)
coordinates = m.get(analyzer['distance'], element)['value']
if coordinates == None:
a = 1
else:
distancia = dinstancefunction(
np.radians(float(coordinates['latitud'])),
np.radians(float(coordinates['longitud'])), float(latitud),
float(longitud))
if distance >= distancia:
distance = distancia
closer = element
return closer
