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