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