def ObtenerAccidentesPorHora(lst):
lista=[]
dik={"Severidad1":0,"Severidad2":0,"Severidad3":0,"Severidad4":0}
m=0
iterator = it.newIterator(lst)
while it.hasNext(iterator):
itet=it.next(iterator)
tamanor=lt.size(itet["listaccidentes"])
i=0
while i!=tamanor:
iterator3=it.newIterator(itet["listaccidentes"])
while it.hasNext(iterator3):
itat=it.next(iterator3)
if int(itat["Severity"])==1:
dik["Severidad1"]=dik["Severidad1"]+1
elif int(itat["Severity"])==2:
dik["Severidad2"]=dik["Severidad2"]+1
elif int(itat["Severity"])==3:
dik["Severidad3"]=dik["Severidad3"]+1
elif int(itat["Severity"])==4:
dik["Severidad4"]=dik["Severidad4"]+1
i+=1
m=m+i
lista.append(m)
if m!=0:
porcentajesev1=round(((dik["Severidad1"]/m)*100),2)
porcentajesev2=round(((dik["Severidad2"]/m)*100),2)
porcentajesev3=round(((dik["Severidad3"]/m)*100),2)
porcentajesev4=round(((dik["Severidad4"]/m)*100),2)
lista.append(porcentajesev1)
lista.append(porcentajesev2)
lista.append(porcentajesev3)
lista.append(porcentajesev4)
return (lista,dik)
def Clusters(analyzer,l1,l2):
estructura=scc.KosarajuSCC(analyzer['connections'])
idscc=estructura['idscc']
#print(idscc)
numero=scc.connectedComponents(estructura)
land1=lt.newList()
land2=lt.newList()
vertices=gr.vertices(analyzer['connections'])
a=lit.newIterator(vertices)
answer=False
while lit.hasNext(a):
c=lit.next(a)
h=c.split("-")
#print(h)
#if h[0] not in Lista:
if h[0]==l1:
lt.addLast(land1, c)
if h[0]==l2:
lt.addLast(land2, c)
la1=lit.newIterator(land1)
while lit.hasNext(la1):
b=lit.next(la1)
entry=mp.get(idscc,b)
cluster=me.getValue(entry)
#print(cluster)
la2=lit.newIterator(land2)
while lit.hasNext(la2):
c=lit.next(la2)
entry=mp.get(idscc,c)
cluster1=me.getValue(entry)
if cluster1==cluster:
#print(cluster1)
answer=True
return (answer,numero)
return (answer,numero)
def __init__(self, catalog):
super_list = mp.valueSet(catalog.videos)
self.super_iter = lliterator.newIterator(super_list)
country_map = lliterator.next(self.super_iter)
country_list = mp.valueSet(country_map)
self.country_iter = lliterator.newIterator(country_list)
self.category_iter = aliterator.newIterator(
lliterator.next(self.country_iter))
def distPaises (analyzer,paisA,paisB):
pA=me.getValue(mp.get(analyzer['countries'],paisA))
minin=1000000
listi=lt.newList()
loc1=(float(pA['CapitalLatitude']),float(pA['CapitalLongitude']))
for landingp in (analyzer['landingpoints']['table']['elements']):
if landingp['key']!=None:
land=me.getValue(mp.get(analyzer['landingpoints'], landingp['key']))
loc2=(float(land['latitude']),float(land['longitude']))
dist=hs.haversine(loc1,loc2)
if dist<minin:
minin=dist
landeA=land['landing_point_id']
pB=me.getValue(mp.get(analyzer['countries'],paisB))
Lista=lt.newList()
dist=0
mini=10000000
loc1=(float(pB['CapitalLatitude']),float(pB['CapitalLongitude']))
for landingp in (analyzer['landingpoints']['table']['elements']):
if landingp['key']!=None:
land=me.getValue(mp.get(analyzer['landingpoints'], landingp['key']))
loc2=(float(land['latitude']),float(land['longitude']))
dist=hs.haversine(loc1,loc2)
if dist<mini:
mini=dist
landes=land['landing_point_id']
vertices=gr.vertices(analyzer['connections'])
a=lit.newIterator(vertices)
while lit.hasNext(a):
c=lit.next(a)
h=c.split("-")
if h[0]==landes:
lt.addLast(Lista, c)
if h[0]==landeA:
x=c
lt.addLast(listi, c)
dist=-1
path="No"
disti=1000000000000000
pathh="No"
t=lit.newIterator(listi)
while lit.hasNext(t):
y=lit.next(t)
route=dij.Dijkstra(analyzer['connections'],y)
a=lit.newIterator(Lista)
while lit.hasNext(a):
e=lit.next(a)
path=dij.hasPathTo(route, e)
if path==True:
dist=dij.distTo(route, e)
path=dij.pathTo(route, e)
if path !=None and dist<disti:
disti=dist
return(path,disti)
def count_artists_2(rango, reproducciones) -> int:
artists_ids = mp.newMap(numelements=reproducciones)
rango_it = ll_it.newIterator(rango)
while ll_it.hasNext(rango_it):
mp.put(artists_ids, ll_it.next(rango_it), 1)
artist_list = lt.newList()
artist_full_list = mp.keySet(artists_ids)
iterator = ll_it.newIterator(artist_full_list)
for i in range(0, 10):
if not ll_it.hasNext(iterator):
break
lt.addLast(artist_list, ll_it.next(iterator))
return mp.size(artists_ids), artist_list
def addConnection(analyzer):
vertices=gr.vertices(analyzer['connections'])
a=lit.newIterator(vertices)
while lit.hasNext(a):
c=lit.next(a)
b=lit.newIterator(vertices)
while lit.hasNext(b):
d=lit.next(b)
if c!=d:
h=c.split("-")
j=d.split("-")
if h[0]==j[0]:
addLine(analyzer,100,c,d)
def all_points_cluster(self, cluster):
vertex_it = ll_it.newIterator(mp.keySet(self.data.clusters['idscc']))
while ll_it.hasNext(vertex_it):
vertex = ll_it.next(vertex_it)
if mp.get(self.data.clusters['idscc'], vertex)['value'] == cluster:
self.graph_point(vertex)
self.m.save('Data/map.html')
def req_2(self, country: str):
repeticiones = mp.newMap(numelements=20000)
for video in country_iterator(self, country):
video_id = lt.getElement(video[0], 1)
video_pair = mp.get(repeticiones, video_id)
if video_pair:
mp.put(repeticiones, video_id,
(video, video_pair['value'][1] + 1))
else:
mp.put(repeticiones, video_id, (video, 1))
videos_ids = mp.keySet(repeticiones)
id_iter = lliterator.newIterator(videos_ids)
maximo = 0
max_id = 0
while lliterator.hasNext(id_iter):
video_id = lliterator.next(id_iter)
video = mp.get(repeticiones, video_id)['value']
video_rep = video[1]
if video_rep > maximo:
maximo = video_rep
max_id = video_id
res = lt.newList()
res_vid = mp.get(repeticiones, video_id)['value']
lt.addFirst(res, res_vid[0])
return (res, res_vid[1])
def Requirement2(analyzer):
tracemalloc.start()
delta_time = -1.0
delta_memory = -1.0
start_time = getTime()
start_memory = getMemory()
vertices = gr.vertices(analyzer["connections_origin_destination"])
size_max = 0
iterator1 = it.newIterator(vertices)
while it.hasNext(iterator1):
element = it.next(iterator1)
adjacents = gr.adjacents(analyzer["connections_origin_destination"],
element)
size = lt.size(adjacents)
if size >= size_max:
size_max = size
result = greaterLandingPoint(analyzer, element)
stop_memory = getMemory()
stop_time = getTime()
tracemalloc.stop()
delta_time = stop_time - start_time
delta_memory = deltaMemory(start_memory, stop_memory)
return size_max, result, delta_time, delta_memory
def __init__(self, catalog, category):
self.category = category
super_list = mp.valueSet(catalog.videos)
self.super_iter = lliterator.newIterator(super_list)
country_map = lliterator.next(self.super_iter)
category_list = mp.get(country_map, category)['value']
self.category_iter = aliterator.newIterator(category_list)
def createTempoList(tempoMap, loTempo, hiTempo):
listOfLists = om.values(tempoMap, loTempo, hiTempo)
tempoList = lt.newList(datastructure='SINGLE_LINKED')
iteratorLists = slit.newIterator(listOfLists)
while slit.hasNext(iteratorLists):
list = slit.next(iteratorLists)
iteratorSongs = slit.newIterator(list)
while slit.hasNext(iteratorSongs):
song = slit.next(iteratorSongs)
lt.addLast(tempoList, song)
return tempoList
def createCharList(charMap, loValue, hiValue):
listOfLists = om.values(charMap, loValue, hiValue)
charList = lt.newList(datastructure='SINGLE_LINKED')
iteratorLists = slit.newIterator(listOfLists)
while slit.hasNext(iteratorLists):
list = slit.next(iteratorLists)
iteratorSongs = slit.newIterator(list)
while slit.hasNext(iteratorSongs):
song = slit.next(iteratorSongs)
lt.addLast(charList, song)
return charList
def addCapital(analyzer):
#print("Capital")
Lista=lt.newList()
for capital in (analyzer['countries']['table']['elements']):
if capital['key']!=None:
cap=me.getValue(mp.get(analyzer['countries'], capital['key']))
mini=100000000000
dist=0
landes=" "
loc1=(float(cap['CapitalLatitude']),float(cap['CapitalLongitude']))
for landingp in (analyzer['landingpoints']['table']['elements']):
if landingp['key']!=None and landingp['key'] not in Lista:
land=me.getValue(mp.get(analyzer['landingpoints'], landingp['key']))
loc2=(float(land['latitude']),float(land['longitude']))
dist=hs.haversine(loc1,loc2)
if dist<mini:
mini=dist
landes=land['landing_point_id']
vertices=gr.vertices(analyzer['connections'])
a=lit.newIterator(vertices)
while lit.hasNext(a):
c=lit.next(a)
h=c.split("-")
#print(h)
#if h[0] not in Lista:
if h[0]==landes:
#print(h[0],c)
#print(h[0])
addLine(analyzer,mini,cap['CapitalName'],c)
#
#print(cap['CapitalName'],c)
lt.addLast(Lista, landes)
def print_req_4(resultado):
iterator = ll_it.newIterator(resultado)
while ll_it.hasNext(iterator):
res = tuple(ll_it.next(iterator))
print("{} tiene {} y {} artistas".format(*res[0:3]))
print("Artistas de {}".format(res[0]))
aux_print_4(res[3])
print("\n\n")
def hallar_categoria(lst):
lista=[]
iterator = it.newIterator(lst)
while it.hasNext(iterator):
itet=it.next(iterator)
iterator2 = it.newIterator(itet["lstaccidents"])
while it.hasNext(iterator2):
itet2=it.next(iterator2)
lista.append(itet2["Severity"])
maxi = 0
ret=None
for severidad in lista:
cant=lista.count(severidad)
if cant > maxi:
maxi = cant
ret=severidad
return (ret,maxi)
def getStateInRange(lst):
lista=[]
iterator = it.newIterator(lst)
while it.hasNext(iterator):
itet=it.next(iterator)
iterator2 = it.newIterator(itet["lstaccidents"])
while it.hasNext(iterator2):
itet2=it.next(iterator2)
lista.append(itet2["State"])
maxi = 0
ret=None
for estado in lista:
cant=lista.count(estado)
if cant > maxi:
maxi = cant
ret=estado
return (ret,maxi)
def max_rep(ans_list):
iterator = ll_it.newIterator(ans_list)
maximo = ('', 0)
while ll_it.hasNext(iterator):
valor = ll_it.next(iterator)
if maximo[1] < valor[1]:
maximo = valor
return maximo
def addCountryToMap(analyzer):
iterator0 = it.newIterator(analyzer['countries'])
while it.hasNext(iterator0):
country = it.next(iterator0)
mp.put(analyzer['countries_map'], country['CountryName'], country)
return analyzer
def req_4(self, genre_list):
genre_it = ll_it.newIterator(genre_list)
ans_list = lt.newList()
while ll_it.hasNext(genre_it):
genre = ll_it.next(genre_it)
temp_min, temp_max = mp.get(self.genres, genre)['value']
temp_min, temp_max = self.req_5_aux_2(temp_min, temp_max)
lt.addLast(ans_list, (genre, *self.req_4_aux(temp_min, temp_max)))
return ans_list
def hallar_muyrepetido(lst):
lista=[]
iterator = it.newIterator(lst)
while it.hasNext(iterator):
itet=it.next(iterator)
iterator2 = it.newIterator(itet["lstaccidents"])
while it.hasNext(iterator2):
itet2=it.next(iterator2)
fechahora=datetime.datetime.strptime(itet2["Start_Time"], '%Y-%m-%d %H:%M:%S')
lista.append(fechahora.date())
maxi = 0
ret=None
for cada_fecha in lista:
cant=lista.count(cada_fecha)
if cant > maxi:
maxi = cant
ret=cada_fecha
return (ret,maxi)
def path_str(self, path):
respuesta = []
path_it = ll_it.newIterator(path)
while ll_it.hasNext(path_it):
edge = ll_it.next(path_it)
dist = round(edge['weight'], 2)
cityA = self.id_to_city(edge['vertexA'])
cityB = self.id_to_city(edge['vertexB'])
respuesta.append("{} - {}: {} km".format(cityA, cityB, dist))
return "\n".join(respuesta)
def addLandingPointToIDMap(analyzer):
iterator0 = it.newIterator(analyzer['landing_points'])
while it.hasNext(iterator0):
landingPoint = it.next(iterator0)
mp.put(analyzer['landing_points_mapID'],
landingPoint['landing_point_id'], landingPoint)
return analyzer
def getAccidentsByState(analyzer, initialDate, finalDate):
rango = om.values(analyzer, initialDate, finalDate)
histograma_estado = {'Estado': None, 'accidents': None}
histograma_fecha = {'Fecha': None, 'accidents': None}
iter = lit.newIterator(histograma_estado)
while lit.hasNext(iter):
entry = lit.next(iter)
if entry['State'] not in histograma_estado:
histograma_estado['Estado'] = 1
else:
histograma_estado['Estado'] += 1
iter = lit.newIterator(histograma_fecha)
while lit.hasNext(iter):
date = lit.next(iter)
if date['dateIndex'] not in histograma_fecha:
histograma_fecha['Fecha'] = 1
else:
histograma_fecha['Fecha'] += 1
maximo_estado = max(histograma_estado.values)
llaves_estado = list(histograma_estado.keys)
iter = lit.newIterator(llaves_estado)
while lit.hasNext(iter):
state = lit.next(iter)
if histograma_estado[state] == maximo_estado:
respuesta_estado = llaves_estado.index(maximo_estado)
maximo_fecha = max(histograma_fecha.values)
llaves_fecha = list(histograma_fecha.keys)
iter = lit.newIterator(llaves_estado)
while lit.hasNext(iter):
fecha = lit.next(iter)
if histograma_fecha[fecha] == maximo_fecha:
respuesta_fecha = llaves_fecha.index(maximo_fecha)
return ("El estado con mayores accidentes en el rango dado es: " +
str(respuesta_estado) + "\n"
"La fecha con mayores accidentes es: " + str(respuesta_fecha))
def fallas(analyzer,vertice):
print(vertice)
Lista=lt.newList()
listi=lt.newList()
#recorrer map con los landing points y decir que si vertice == [name:] entonces name=l[name]
vertices=gr.vertices(analyzer['connections'])
b=lit.newIterator(vertices)
name=" "
while lit.hasNext(b) and name== " ":
c=lit.next(b)
if "-" in c:
h=c.split("-")
if h[1]==vertice:
name=c
print("hola")
edges=gr.adjacents(analyzer['connections'], name)
b=lit.newIterator(edges)
while lit.hasNext(b):
c=lit.next(b)
h=c.split("-")
p=me.getValue(mp.get(analyzer['landingpoints'],h[0]))
loc1=(float(p['latitude']),float(p['longitude']))
minin=100000000
landeA=0
for country in (analyzer['countries']['table']['elements']):
if country['key']!=None:
land=me.getValue(mp.get(analyzer['countries'], country['key']))
loc2=(float(land['CapitalLatitude']),float(land['CapitalLongitude']))
dist=hs.haversine(loc1,loc2)
if dist<minin:
minin=dist
print("si")
landeA=land['CountryName']
if landeA !=0:
lt.addLast(Lista, landeA)
return Lista
def graph_path(self, path):
first = True
path_it = ll_it.newIterator(path)
while ll_it.hasNext(path_it):
edge = ll_it.next(path_it)
if first:
self.graph_point(edge['vertexA'])
first = False
self.graph_point(edge['vertexB'])
folium.PolyLine(self.line['elements']).add_to(self.m)
self.m.save('Data/map.html')
def newIterator(lst):
"""
Inicializa un iterador para la lista lst
Args:
lst: La lista sobre la que se quiere iterar
Returns:
Un iterador para la lista
"""
if (lst['type'] == 'ARRAY_LIST'):
return ait.newIterator(lst)
else:
return lit.newIterator(lst)
def req_5(self):
genre_list = mp.keySet(self.genres)
genre_it = ll_it.newIterator(genre_list)
ans_list = lt.newList()
while ll_it.hasNext(genre_it):
genre = ll_it.next(genre_it)
temp_min, temp_max = mp.get(self.genres, genre)['value']
temp_min, temp_max = self.req_5_aux_2(temp_min, temp_max)
reproducciones = self.req_5_aux(temp_min, temp_max)
lt.addLast(ans_list, (genre, reproducciones))
maximo = max_rep(ans_list)
return ans_list, maximo
def total_antes_de_una_fecha(analyzer, fecha):
date = fecha_convertidor_consultas(fecha)
a = om.keys(analyzer["index"], om.minKey(analyzer["index"]), date)
lt.removeLast(a)
total = 0
it1 = lit.newIterator(a)
while lit.hasNext(it1):
n = lit.next(it1)
b = om.get(analyzer["index"], n)
c = me.getValue(b)
total += lt.size(c)
return total
def matchGraphKeyDestination(analyzer, id_landingpoint):
result = ""
iterator1 = it.newIterator(analyzer["connections"])
while it.hasNext(iterator1):
element = it.next(iterator1)
if element["destination"] == id_landingpoint:
result = createVertexDestination(element)
return result
def total_entre_fechas(analyzer, fecha1, fecha2):
date1 = fecha_convertidor_consultas(fecha1)
date2 = fecha_convertidor_consultas(fecha2)
a = om.keys(analyzer["index"], date1, date2)
total = 0
it1 = lit.newIterator(a)
while lit.hasNext(it1):
n = lit.next(it1)
b = om.get(analyzer["index"], n)
c = me.getValue(b)
total += lt.size(c)
return total