def addEdge(graph, vertexa, vertexb, weight=0):
"""
Agrega un arco entre los vertices vertexa ---- vertexb, con peso weight.
Si el grafo es no dirigido se adiciona dos veces el mismo arco, en el mismo orden
Si el grafo es dirigido se adiciona solo el arco vertexa --> vertexb
"""
try:
# Se crea el arco
edge = e.newEdge(vertexa, vertexb, weight)
#Se obtienen las listas de adyacencias de cada vertice
#Se anexa a cada lista el arco correspondiente
entrya = map.get(graph['vertices'], vertexa)
lt.addLast(entrya['value'], edge)
if (not graph['directed']):
entryb = map.get(graph['vertices'], vertexb)
lt.addLast(entryb['value'], edge)
else:
degree = map.get(graph['indegree'], vertexb)
map.put(graph['indegree'], vertexb, degree['value'] + 1)
graph['edges'] += 1
return graph
except:
return None
def stronglyConnected(self, idscc, verta, vertb):
"""
Dados dos vértices, informa si están fuertemente conectados o no.
"""
if m.get(idscc, verta)['value'] == m.get(idscc, vertb)['value']:
return True
return False
def add_gen(catalog, row):
generos = catalog['generos']
split_gen = row['genres'].split('|')
for i in split_gen:
if map.contains(generos, i, compareByKey):
map.get(generos, i, compareByKey)['peliculas'] += 1
else:
x = new_gen(row['genres'])
map.put(generos, i, x, compareByKey)
def relax(search, edge):
v = e.either(edge)
w = e.other(edge, v)
visited_v = map.get(search['visitedMap'], v)['value']
visited_w = map.get(search['visitedMap'], w)['value']
if visited_w['distTo'] > (visited_v['distTo'] + e.weight(edge)):
distToW = visited_v['distTo'] + e.weight(edge)
map.put(search['visitedMap'], w, {'marked':True,'edgeTo':edge,'distTo':distToW})
if minpq.contains(search['minpq'], w):
minpq.decreasePriority(search['minpq'], w, distToW)
else:
minpq.insert(search['minpq'], w, distToW)
def get_movies_by_title(catalog, name):
x = map.get(catalog['MovieMap_title'], name, compareByKey)
if x:
vote = x['vote_average']
votos_totales = x['vote_count']
director_id = x['id']
director = map.get(catalog['Directors_id'], director_id,
compareByKey)['name']
return ('El numero de votos es: ', str(votos_totales),
'\nEl promedio de votos es: ', str(vote),
'\nEl director de la pelicula es: ', str(director))
else:
return 'No se encontro la pelicula'
def get_director_info(catalog, name):
director = map.get(catalog['Directors_name'], name, compareByKey)
if director:
num_peli = lt.size(director['DirectorMovies'])
vote_aver = director['sum_aver'] / num_peli
peliculas = []
for i in range(1, num_peli + 1):
id = lt.getElement(director['DirectorMovies'], i)
peliculas.append(
map.get(catalog['MovieMap_id'], id, compareByKey)['title'])
return ('El director ', name, 'a dirigido ', str(num_peli),
' peliculas con un voto promedio de ', str(vote_aver),
' las peliculas del director son:\n', str(peliculas))
else:
return 'No se encontro el director'
def bfs (search, source):
queue = q.newQueue()
q.enqueue(queue, source)
while not (q.isEmpty(queue)):
v = q.dequeue (queue)
visited_v = map.get(search['visitedMap'], v)['value']
adjs = g.adjacents(search['graph'], v)
adjs_iter = it.newIterator (adjs)
while (it.hasNext(adjs_iter)):
w = it.next (adjs_iter)
print(w)
visited_w = map.get(search['visitedMap'], w)
if visited_w == None:
map.put(search['visitedMap'], w, {'marked':True, 'edgeTo':v})
q.enqueue(queue, w)
def addEdge(graph, vertexa, vertexb, weight=0):
"""
Agrega un arco entre los vertices vertexa ---- vertexb, con peso weight
"""
# Se crea el arco
edge = e.newEdge(vertexa, vertexb, weight)
#Se obtienen las listas de adyacencias de cada vertice
entrya = map.get(graph['vertices'], vertexa)
entryb = map.get(graph['vertices'], vertexb)
#Se anexa a cada lista el arco correspondiente
lt.addLast(entrya['value'], edge)
lt.addLast(entryb['value'], edge)
graph['edges'] += 1
def degree(graph, vertex):
"""
Retorna el numero de arcos asociados al vertice vertex
"""
element = map.get(graph['vertices'], vertex)
lst = element['value']
return (lt.size(lst))
def getBooksCountByYearRange(catalog, years):
"""
Retorna la cantidad de libros por rating para un rango de años
"""
startYear = strToDate(years.split(" ")[0], '%Y-%m-%d')
endYear = strToDate(years.split(" ")[1], '%Y-%m-%d')
yearList = tree.valueRange(catalog['yearsTree'], startYear, endYear,
greater)
counter = 0
cities = map.newMap(40009, maptype='PROBING')
if yearList:
iteraYear = it.newIterator(yearList)
while it.hasNext(iteraYear):
yearElement = it.next(iteraYear)
#print(yearElement['year'],yearElement['count'])
counter += yearElement['count']
keys = map.keySet(yearElement['ratingMap'])
for i in range(1, lt.size(keys)):
city_key = lt.getElement(keys, i)
city = map.get(cities, city_key, compareByKey)
if city:
city['Accidentes'] += 1
else:
ciudad = {'ciudad': city_key, 'Accidentes': 1}
map.put(cities, ciudad['ciudad'], ciudad, compareByKey)
total = {'total_Accidentes': counter}
map.put(cities, 'total', total, compareByKey)
return cities
return None
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 test_LoadTable(self):
table_capacity = 171
book_map = ht.newMap(capacity=table_capacity,
maptype='CHAINING',
comparefunction=self.compare_book_id)
booksfile = cf.data_dir + 'GoodReads/books-small.csv'
self.assertEqual(ht.size(book_map), 0)
self.assertTrue(ht.isEmpty(book_map))
input_file = csv.DictReader(open(booksfile))
for book in input_file:
ht.put(book_map, book['book_id'], book)
self.assertEqual(ht.size(book_map), 149)
self.assertTrue(ht.contains(book_map, '100'))
entry = ht.get(book_map, '100')
self.assertIsNotNone(entry)
self.assertEqual(entry['value']['book_id'], '100')
ht.remove(book_map, '100')
self.assertEqual(ht.size(book_map), 148)
self.assertFalse(ht.contains(book_map, '100'))
lst_keys = ht.keySet(book_map)
self.assertFalse(lt.isEmpty(lst_keys))
self.assertEqual(lt.size(lst_keys), 148)
lst_values = ht.valueSet(book_map)
self.assertFalse(lt.isEmpty(lst_values))
self.assertEqual(lt.size(lst_values), 148)
def path(mapa,lista, source, dst):
if source == dst:
return lista
vertice= map.get(mapa, source)
anterior= vertice['edgeTo']
lt.addFirst(lista, anterior)
path(mapa,lista,anterior,dst)
def test_LoadTable(self):
self.assertEqual(ht.size(self.book_map), 0)
self.assertTrue(ht.isEmpty(self.book_map))
input_file = csv.DictReader(open(self.booksfile))
for book in input_file:
ht.put(self.book_map, book['book_id'], book, self.compare_book_id)
self.assertEqual(ht.size(self.book_map), 149)
self.assertTrue(ht.contains(self.book_map, '100',
self.compare_book_id))
entry = ht.get(self.book_map, '100', self.compare_book_id)
self.assertIsNotNone(entry)
self.assertEqual(entry['value']['book_id'], '100')
ht.remove(self.book_map, '100', self.compare_book_id)
self.assertEqual(ht.size(self.book_map), 148)
self.assertFalse(
ht.contains(self.book_map, '100', self.compare_book_id))
lst_keys = ht.keySet(self.book_map)
self.assertFalse(lt.isEmpty(lst_keys))
self.assertEqual(lt.size(lst_keys), 148)
lst_values = ht.valueSet(self.book_map)
self.assertFalse(lt.isEmpty(lst_values))
self.assertEqual(lt.size(lst_values), 148)
def getAccidentsByDateRange (catalog, dates):
startDate = strToDate(dates.split(" ")[0],'%Y-%m-%d')
endDate = strToDate(dates.split(" ")[1],'%Y-%m-%d')
dateList = tree.valueRange(catalog['dateTree'], startDate, endDate, greater)
# print(dateList)
#hol= lt.getElement(dateList,13)
#print(hol)
iteraDates = it.newIterator(dateList)
cities = {}
count = 0
while it.hasNext(iteraDates):
dateElement = it.next(iteraDates)
if dateElement:
citiesList = map.keySet(dateElement['cityMap'])
iteraCities = it.newIterator(citiesList)
while it.hasNext(iteraCities):
cityKey = it.next(iteraCities)
new = map.get(dateElement['cityMap'],cityKey,compareByKey)
count += new
if cityKey in cities.keys():
cities[cityKey] += new
else:
cities[cityKey]=new
#response += ''+str(cityKey) + ':' + str(map.get(dateElement['cityMap'],cityKey,compareByKey)) + '\n'
response = 'Total de accidentes en el rango: '+str(count)+'\n'
for i in cities:
response += str(i)+": "+str(cities[i])+"\n"
#print (i, cities[i])
#response += str(i[0])+": "+str(i[1])+"\n"
return response
def addDirector(catalog, row):
"""
Adiciona un director al mapa
"""
movies = catalog['idMap']
directors = catalog['directors']
id = row['id']
movie = map.get(movies, id, compareByKey)
average = float(movie['vote_average'])
movieTitle = movie['title']
director = map.get(directors, row['director_name'], compareByKey)
if director:
updateDirector(director, average, movieTitle)
else:
director = newDirector(row, average, movieTitle)
map.put(directors, director['name'], director, compareByKey)
def trips_per_dates(catalog, init_date, last_date):
'''
Función que responde el requerimiento 2; para un rango de fechas devuelve la cantidad de viajes totales por ciudad
'''
# Esta es la que usamos para responder el req 2 , se devulve un dict con llaves = ciudades y value = suma de todas las cantidades
response = {}
date_1 = strToDate(init_date, '%m/%d/%Y')
date_2 = strToDate(last_date, '%m/%d/%Y')
range_list = tree.valueRange(catalog['date_city_trips'], date_1, date_2,
greater)
#print(range_list)
#print(type(range_list))
iterator_range = it.newIterator(range_list)
while it.hasNext(iterator_range):
Element = it.next(iterator_range)
elkeys = map.keySet(Element)
iterator_keys = it.newIterator(elkeys)
while it.hasNext(iterator_keys):
city = it.next(iterator_keys)
count = map.get(Element, city)['value']
if city in response:
r = response[city]
w = r + count
response[city] = w
else:
response[city] = count
return response
def addDate_city_trips(catalog, row):
'''
Función que construye el árbol RBT de fechas. Cada nodo del árbol es a su vez un mapa de hash con cantidad de viajes indexados por ciudad
'''
# Añadimos las fechas al RBT con un value igual a un map con ciudad y values = cantidad de viajes
d = row['start_date'] # row del archivo trip.csv
t = d.split(" ")[0]
date = strToDate(t, '%m/%d/%Y')
#print(date)
id_station = row['start_station_id']
city_trip = tree.get(catalog['date_city_trips'], date, greater)
#print(city_trip)
city = station_id_city(catalog, id_station)
if city_trip:
if map.contains(city_trip, city):
u = map.get(city_trip, city)['value']
u += 1
map.put(city_trip, city, u)
catalog['date_city_trips'] = tree.put(catalog['date_city_trips'],
date, city_trip, greater)
else:
map.put(city_trip, city, 1)
catalog['date_city_trips'] = tree.put(catalog['date_city_trips'],
date, city_trip, greater)
else:
city_trip = map.newMap(capacity=5,
prime=3,
maptype='CHAINING',
comparefunction=compareByKey)
map.put(city_trip, city, 1)
catalog['date_city_trips'] = tree.put(catalog['date_city_trips'], date,
city_trip, greater)
def addCityStations(catalog, row):
'''
Función que va construyendo un mapa de ciudades, añadiendo a cada ciudad una lista con sus estaciones respectivas.
Cada estación contiene un diccionario con su ID, Nombre, y Dock Count.
'''
#Vamos actualizando el mapa de ciudades, añadiendo la estación a la ciudad respectiva
cityStationsMap = catalog['cities']
station = {
'id': row['id'],
'name': row['name'],
'dock_count': row['dock_count']
}
if map.contains(cityStationsMap, row['city']) == False:
stationsList = lt.newList(datastructure='ARRAY_LIST')
lt.addLast(stationsList, station)
map.put(cityStationsMap, row['city'], stationsList)
if map.contains(cityStationsMap, row['city']) == True:
stationsList = map.get(cityStationsMap, row['city'])['value']
lt.addLast(stationsList, station)
map.put(cityStationsMap, row['city'], stationsList)
#Añadimos la estación al mapa de ids con value de nombres de las estaciones y su ciudad
stationsIdName = catalog['stationIds']
dicct = {'Name': row['name'], 'City': row['city']}
map.put(stationsIdName, row['id'], dicct)
def cargar_viajes_dia(catalog):
lista_tem = catalog['list_temepratura']
mapa = catalog['fecha_tally_viajes']
for i in range(1, lt.size(lista_tem)):
elemento = lt.getElement(lista_tem, i)
fecha = elemento['dia']
fech_map = map.get(mapa, fecha)
elemento['total'] = fech_map['total']
def get_generos(catalog, gen):
genero = map.get(catalog['generos'], gen, compareByKey)
if genero:
numero = genero['peliculas']
return ('El genero ', gen, 'tiene ', str(numero),
'peliculas relacionadas')
else:
return 'No se encontro el genero'
def containsVertex(graph, vertex):
"""
Verifica si el grafo contiene un vertice
"""
try:
return map.get(graph['vertices'], vertex) != None
except:
return None
def increasePriority(minPQ, index, priority):
val = map.get(minPQ['qpMap'], index)
if val == None:
raise Exception("Index [" + index + "] doesn't exist")
elem = minPQ['pq'][val['value']]
elem['priority'] = priority
minPQ['pq'][val['value']] = elem
sink(minPQ, val['value'])
def addMovieMapVoteData(catalog, row):
"""
Adiciona información a una película
"""
movies = catalog['moviesMap']
movie = map.get(movies, row["id"], comparemovies)
if movie:
model.addMovieMapVoteData(movie, row)
def addDirectorVoteData(catalog, name, row):
directors = catalog['directors']
director = map.get(directors, name, compareByKey)
if director:
if row["id"] in director["movies_id"]:
lt.addLast(director['movie_titles'], row['title'])
lt.addLast(director['movies_id'], row['id'])
director['sum_average_rating'] += float(row['vote_average'])
def pathTo(search, v):
if hasPathTo(search, v)==False:
return None
path= stk.newStack()
while v != search['s']:
stk.push(path,v)
v = map.get(search['visitedMap'],v)['value']['edgeTo']
stk.push(path,search['s'])
return path
def dfs (search, v):
adjs = g.adjacents(search['graph'],v)
adjs_iter = it.newIterator (adjs)
while (it.hasNext(adjs_iter)):
w = it.next (adjs_iter)
visited_w = map.get(search['visitedMap'], w)
if visited_w == None:
map.put(search['visitedMap'], w, {'marked':True, 'edgeTo':v})
dfs(search, w)
def station_id_city(catalog, station_id):
'''
Función que devuelve la ciudad en la que está ubicada una estación, recibiendo como input el id de la estación
'''
# Funcion auxiliar a addDate_city_trips que me devuelve la ciudad a partir del id de una estacion
stations_ids = catalog['stationIds']
y = map.get(stations_ids, station_id)
city = y['value']['City']
return city
def Add_station_list(catalog, row):
if map.contains(catalog['map_station'], row['city']) == None:
value = lt.newList()
map.put(catalog['map_station'], row['city'], value)
dic = {
'city_id': row['id'],
'dock_count': row['dock_count'],
'city': row['city']
}
lista = map.get(catalog['map_station'], row['city'])
lt.addFirst(lista, dic)
else:
lista = map.get(catalog['map_station'], row['city'])
dic = {
'city_id': row['id'],
'dock_count': row['dock_count'],
'city': row['city']
}
lt.addFirst(lista, dic)
def pathTo(search, v):
if hasPathTo(search, v) == False:
return None
path = stk.newStack()
while v != search['s']:
visited_v = map.get(search['visitedMap'], v)['value']
edge = visited_v['edgeTo']
stk.push(path, edge)
v = e.either(edge)
return path
