def communication(): message = request.args['content'] #cogo el contenido enviado grafo = Graph() grafo.parse(data=message) # logger.info('--Envian una comunicacion') message_properties = get_message_properties(grafo) resultado_comunicacion = None if message_properties is None: # Respondemos que no hemos entendido el mensaje resultado_comunicacion = build_message(Graph(), ACL['not-understood'], sender=AgenteGestorDeVentas.uri, msgcnt=get_message_count()) else: # Obtenemos la performativa if message_properties['performative'] != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje resultado_comunicacion = build_message(Graph(), ACL['not-understood'], sender=AgenteGestorDeVentas.uri, msgcnt=get_message_count()) else: #Extraemos el contenido que ha de ser una accion de la ontologia contenido = message_properties['content'] accion = grafo.value(subject=contenido, predicate=RDF.type) logger.info("La accion es: " + accion) # Si la acción es de tipo iniciar_venta empezamos if accion == ECSDIAmazon.Iniciar_venta: for item in grafo.subjects(RDF.type, ACL.FipaAclMessage): grafo.remove((item, None, None)) resultado_comunicacion = vender_productos(contenido, grafo) logger.info('Antes de serializar la respuesta') serialize = resultado_comunicacion.serialize(format='xml') return serialize, 200
def comunicacion(): message = request.args['content'] #cogo el contenido enviado grafo = Graph() grafo.parse(data=message) message_properties = get_message_properties(grafo) resultado_comunicacion = None if message_properties is None: # Respondemos que no hemos entendido el mensaje resultado_comunicacion = build_message(Graph(), ACL['not-understood'], sender=AgenteCL.uri, msgcnt=get_message_count()) else: # Obtenemos la performativa if message_properties['performative'] != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje resultado_comunicacion = build_message(Graph(), ACL['not-understood'], sender=AgenteCL.uri, msgcnt=get_message_count()) else: #Extraemos el contenido que ha de ser una accion de la ontologia contenido = message_properties['content'] accion = grafo.value(subject=contenido, predicate=RDF.type) logger.info("La accion es: " + accion) # Si la acción es de tipo iniciar_venta empezamos if accion == ECSDIAmazon.Encargo_envio: resultado_comunicacion = gestionarEncargo(contenido, grafo) serialize = resultado_comunicacion.serialize(format='xml') return serialize, 200
def process_search(): # Asumimos que hay una accion de busqueda que puede tener # diferentes parametros en funcion de si se busca un tipo de agente # o un agente concreto por URI o nombre # Podriamos resolver esto tambien con un query-ref y enviar un objeto de # registro con variables y constantes # Solo consideramos cuando Search indica el tipo de agente # Buscamos una coincidencia exacta # Retornamos el primero de la lista de posibilidades logger.info('Peticion de busqueda') agn_type = gm.value(subject=content, predicate=DSO.AgentType) rsearch = dsgraph.triples((None, DSO.AgentType, agn_type)) if rsearch is not None: agn_uri = next(rsearch)[0] agn_add = dsgraph.value(subject=agn_uri, predicate=DSO.Address) gr = Graph() gr.bind('dso', DSO) rsp_obj = agn['Directory-response'] gr.add((rsp_obj, DSO.Address, agn_add)) gr.add((rsp_obj, DSO.Uri, agn_uri)) return build_message(gr, ACL.inform, sender=DirectoryAgent.uri, msgcnt=mss_cnt, receiver=agn_uri, content=rsp_obj) else: # Si no encontramos nada retornamos un inform sin contenido return build_message(Graph(), ACL.inform, sender=DirectoryAgent.uri, msgcnt=mss_cnt)
def comunicacion(): """ Communication Entrypoint """ global dsGraph logger.info('Aviso a Tienda Externa de Compra Realizada') message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) gr = None if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgenteExternoTiendaExterna.uri, msgcnt=get_count()) else: # El AgenteNegociadorTiendasExternas nos informa de que ha habido una compra de uno de nuestros productos if msgdic['performative'] != ACL.inform: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteExternoTiendaExterna.uri, msgcnt=get_count()) else: procesarCompra()
def process_search(): # Asumimos que hay una accion de busqueda que puede tener # diferentes parametros en funcion de si se busca un tipo de agente # o un agente concreto por URI o nombre # Podriamos resolver esto tambien con un query-ref y enviar un objeto de # registro con variables y constantes # Solo consideramos cuando Search indica el tipo de agente # Buscamos una coincidencia exacta # Retornamos el primero de la lista de posibilidades logger.info('Peticion de busqueda') agn_type = gm.value(subject=content, predicate=DSO.AgentType) rsearch = dsgraph.triples((None, DSO.AgentType, agn_type)) if rsearch is not None: agn_uri = rsearch.next()[0] agn_add = dsgraph.value(subject=agn_uri, predicate=DSO.Address) gr = Graph() gr.bind('dso', DSO) rsp_obj = agn['Directory-response'] gr.add((rsp_obj, DSO.Address, agn_add)) gr.add((rsp_obj, DSO.Uri, agn_uri)) return build_message(gr, ACL.inform, sender=DirectoryAgent.uri, msgcnt=mss_cnt, receiver=agn_uri, content=rsp_obj) else: # Si no encontramos nada retornamos un inform sin contenido return build_message(Graph(), ACL.inform, sender=DirectoryAgent.uri, msgcnt=mss_cnt)
def comunicacion(): logger.info("Peticion recibida") global mss_cnt global dsgraph message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) gr = None if msgdic is None: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteDevoluciones.uri, msgcnt=get_count()) else: if msgdic['performative'] != ACL.request: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteDevoluciones.uri, msgcnt=get_count()) else: content = msgdic['content'] accion = gm.value(subject=content, predicate=RDF.type) if accion == ECSDI.Devolver_producto: logger.info("Peticion de retorno") if gm.value(subject=accion, predicate=RDF.type) == ECSDI.Devolucion_insatisfaccion and fuera_plazo(gm, content): # si se ha comprado hace mas de 15 dias, rechazado gr = build_message(Graph(), ACL['refuse'], sender=AgenteDevoluciones.uri, msgcnt=get_count()) else: comprasbd = open("../data/productos_pedidos.owl") gcomp = Graph() gcomp.parse(comprasbd, format='turtle') compras = gm.subjects(predicate=RDF.type, object=ECSDI.Compra) pesototal = 0.0 logger.info("fuera") for compra in compras: logger.info("dentro") productos = gcomp.objects(subject=compra, predicate=ECSDI.Productos) for prod in productos: gcomp.remove((compra, ECSDI.Productos, prod)) peso = gcomp.value(subject=prod, predicate=ECSDI.Peso) logger.info(peso) pesototal += peso.toPython() gcomp.remove((compra,RDF.type, ECSDI.Compra)) comprasbd.close() gcomp.serialize(destination='../data/productos_pedidos.owl', format='turtle') gr = Graph() gr.add((content, RDF.type, ECSDI.Devolver_producto)) gr.add((content, ECSDI.Peso_lote, Literal(pesototal))) centroLogistico = get_agent_info(agn.AgenteCentroLogistico, AgenteDirectorio, AgenteDevoluciones, get_count()) gr = send_message(build_message(gr, perf=ACL.request, sender=AgenteDevoluciones.uri, receiver=centroLogistico.uri, msgcnt=get_count(), content=content), centroLogistico.address) else: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteDevoluciones.uri, msgcnt=get_count()) logger.info('Respondemos a la peticion') return gr.serialize(format='xml')
def comunicacion(): """ Entrypoint de comunicacion del agente Simplemente retorna un objeto fijo que representa una respuesta a una busqueda de hotel Asumimos que se reciben siempre acciones que se refieren a lo que puede hacer el agente (buscar con ciertas restricciones, reservar) Las acciones se mandan siempre con un Request Prodriamos resolver las busquedas usando una performativa de Query-ref """ global dsgraph global mss_cnt logger.info('Peticion de informacion recibida') # Extraemos el mensaje y creamos un grafo con el message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) # Comprobamos que sea un mensaje FIPA ACL if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgentDevoluciones.uri, msgcnt=mss_cnt) else: # Obtenemos la performativa perf = msgdic['performative'] if perf != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgentDevoluciones.uri, msgcnt=mss_cnt) else: # Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente # de registro # Averiguamos el tipo de la accion content = msgdic['content'] accion = gm.value(subject=content, predicate=RDF.type) if accion == ONT.ProductoDevuelto: gr = contactarCobrador(gm) mss_cnt += 1 logger.info('Respondemos a la peticion') return gr.serialize(format='xml')
def comunicacion(): """ Entrypoint de comunicacion del agente Simplementet retorna un objeto fijo que representa una respuesta a una busqueda de hotel Asumimos que se reciben siempre acciones que se refieren a lo que puede hacer el agente (buscar con ciertas restricciones, reservar) Las acciones se mandan siempre con un Request Prodriamos resolver las busquedas usando una performativa de Query-ref """ global dsgraph global mss_cnt #Extraemos el mensaje y creamos un grafo con el message= request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) # Comprobamos que sea un mensaje FIPA ACL if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=InfoAgent.uri, msgcnt=mss_cnt) else: # Obtenemos la performativa perf = msgdic['performative'] if perf != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=InfoAgent.uri, msgcnt=mss_cnt) else: #Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente # de registro # Averiguamos el tipo de la accion if 'content' in msgdic: content = msgdic['content'] accion = gm.value(subject=content, predicate= RDF.type) # Aqui realizariamos lo que pide la accion paq = paquet["vacances"] actTypes = gm.value(subject= paq, predicate= paquet.act_types) destination = gm.value(subject= paq, predicate= paquet.desti) ga = buscar_activitats(destination, actTypes) # Por ahora simplemente retornamos un Inform-done gr = build_message(ga, ACL['inform-done'], sender=InfoAgent.uri, msgcnt=mss_cnt, receiver=msgdic['sender'],) mss_cnt += 1 return gr.serialize(format='xml')
def comunicacion(): logger.info("Peticion recibida") global mss_cnt global dsgraph message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) gr = None if msgdic is None: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteBuscador.uri, msgcnt=get_count()) else: if msgdic['performative'] != ACL.request: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteBuscador.uri, msgcnt=get_count()) else: content = msgdic['content'] accion = gm.value(subject=content, predicate=RDF.type) if accion == ECSDI.Buscar: restricciones = gm.objects(content, ECSDI.Restringe) restricciones_dict = {} for restriccion in restricciones: if gm.value(subject=restriccion, predicate=RDF.type) == ECSDI.Restriccion_Marca: marca = gm.value(subject=restriccion, predicate=ECSDI.Marca) logger.info("Marca: "+marca) restricciones_dict['marca'] = marca elif gm.value(subject=restriccion, predicate=RDF.type) == ECSDI.Restriccion_Modelo: modelo = gm.value(subject=restriccion, predicate=ECSDI.Modelo) logger.info('Modelo: ' + modelo) restricciones_dict['modelo'] = modelo elif gm.value(subject=restriccion, predicate=RDF.type) == ECSDI.Restriccion_Precio: precio_max = gm.value(subject=restriccion, predicate=ECSDI.Precio_max) precio_min = gm.value(subject=restriccion, predicate=ECSDI.Precio_min) if precio_min: logger.info('Precio minimo: ' + precio_min) restricciones_dict['precio_min'] = precio_min logger.info(restricciones_dict['precio_min']) if precio_max: logger.info('Precio maximo: ' + precio_max) restricciones_dict['precio_max'] = precio_max gr = buscarProductos(**restricciones_dict) gr = build_message(gr, perf=ACL['inform-done'], sender=AgenteBuscador.uri, msgcnt=get_count(), receiver=msgdic['sender']) else: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteBuscador.uri, msgcnt=get_count()) logger.info('Respondemos a la peticion') return gr.serialize(format='xml')
def comunicacion(): """ Entrypoint de comunicacion """ global dsgraph global mss_cnt # Extraemos el mensaje y creamos un grafo con el message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) # Comprobamos que sea un mensaje FIPA ACL if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlmacen.uri, msgcnt=mss_cnt) else: # Obtenemos la performativa perf = msgdic['performative'] if perf != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlmacen.uri, msgcnt=mss_cnt) else: # Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente # de registro # Averiguamos el tipo de la accion if 'content' in msgdic: content = msgdic['content'] accion = gm.value(subject=content, predicate=RDF.type) # Aqui realizariamos lo que pide la accion if accion == AM2.Realiza_envio: logger.info('Realizando el envio') products = Graph() for s in gm.subjects(RDF.type,AM2["Producto"]): products += gm.triples((s,None,None)) # for s,p,o in products: # print("Procesando productos: %s | %s | %s"%(s,p,o)) negociaEnvio() time.sleep(10) #Hacemos que tarde un tiempo en procesar antes de confirmar el envio gr = confirmaEnvio(msgdic) else: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlmacen.uri, msgcnt=mss_cnt) else: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlmacen.uri, msgcnt=mss_cnt) mss_cnt += 1 logger.info('Confirmamos que se ha relizado el envio') return gr.serialize(format='xml')
def comunicacion(): """ Entrypoint de comunicacion """ global dsgraph global mss_cnt # Extraemos el mensaje y creamos un grafo con el message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) mss_cnt += 1 # Comprobamos que sea un mensaje FIPA ACL if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgenteVendedorExterno.uri, msgcnt=mss_cnt) else: # Obtenemos la performativa perf = msgdic['performative'] if perf != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgenteVendedorExterno.uri, msgcnt=mss_cnt) else: # Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente # de registro # Averiguamos el tipo de la accion if 'content' in msgdic: content = msgdic['content'] accion = gm.value(subject=content, predicate=RDF.type) # Aqui realizariamos lo que pide la accion gr = build_message(Graph(), ACL['not-understood'], sender=AgenteVendedorExterno.uri, msgcnt=mss_cnt) else: gr = build_message(Graph(), ACL['not-understood'], sender=AgenteVendedorExterno.uri, msgcnt=mss_cnt) return gr.serialize(format='xml')
def process_register(): # Si la hay extraemos el nombre del agente (FOAF.name), el URI del agente # su direccion y su tipo logger.info('Peticion de registro') directory[FOAF.name] = (DSO.AgentType, DSO.Uri, time.strftime('%Y-%m-%d %H:%M')) agn_add = gm.value(subject=content, predicate=DSO.Address) agn_name = gm.value(subject=content, predicate=FOAF.name) agn_uri = gm.value(subject=content, predicate=DSO.Uri) agn_type = gm.value(subject=content, predicate=DSO.AgentType) # Añadimos la informacion en el grafo de registro vinculandola a la URI # del agente y registrandola como tipo FOAF.Agent dsgraph.add((agn_uri, RDF.type, FOAF.Agent)) dsgraph.add((agn_uri, FOAF.name, agn_name)) dsgraph.add((agn_uri, DSO.Address, agn_add)) dsgraph.add((agn_uri, DSO.AgentType, agn_type)) # Generamos un mensaje de respuesta return build_message(Graph(), ACL.confirm, sender=DirectoryAgent.uri, receiver=agn_uri, msgcnt=mss_cnt)
def negociaEnvio(): logger.info('Negociando el envio con transportistas') global mss_cnt gmess = Graph() sj_contenido = MSG[AgenteAlmacen.name + '-Pedir_precio_envio-' + str(mss_cnt)] gmess.add((sj_contenido, RDF.type, AM2.Pedir_precio_envio)) agentesTransportistas = directory_search_agent(DSO.AgenteTransportista,AgenteAlmacen,DirectoryAgent,mss_cnt) mejorOferta = sys.maxint for agenteTransportista in agentesTransportistas: grm = build_message(gmess, perf=ACL.request, sender=AgenteAlmacen.uri, receiver=agenteTransportista.uri, content=sj_contenido, msgcnt=mss_cnt) gr = send_message(grm,agenteTransportista.address) sj_precios = gr.value(predicate = RDF.type, object = AM2['Precios_envio']) precio = gr.value(sj_precios,AM2.precioEnvioTransportista) if int(precio)<mejorOferta: mejorOferta = int(precio) agenteElegido = agenteTransportista logger.info(agenteElegido.name) transportistaContraoferta = contraOfertaEnvio(mejorOferta,agentesTransportistas) if(agenteElegido.name != transportistaContraoferta.name): logger.info("Se ha mejorado la oferta") logger.info(transportistaContraoferta.name)
def contraOfertaEnvio(mejorOferta, agentesTransportistas): logger.info("Realizando Contraoferta") gmess = Graph precioContraoferta = mejorOferta -10 gmess = Graph() sj_contenido = MSG[AgenteAlmacen.name + '-Contraoferta_envio-' + str(mss_cnt)] gmess.add((sj_contenido, RDF.type, AM2.Contraoferta_envio)) sj_contraoferta = AM2['Contraoferta' + str(mss_cnt)] gmess.add((sj_contraoferta, RDF.type, AM2['Contraoferta'])) gmess.add((sj_contraoferta, AM2.precioContraoferta, Literal(precioContraoferta))) gmess.add((sj_contenido, AM2.tieneContraoferta, URIRef(sj_contraoferta))) for agenteTransportista in agentesTransportistas: grm= build_message(gmess, perf=ACL.request, sender=AgenteAlmacen.uri, receiver=agenteTransportista.uri, content=sj_contenido, msgcnt=mss_cnt) gr = send_message(grm,agenteTransportista.address) sj_precios = gr.value(predicate = RDF.type, object = AM2['Precios_envio']) precio = gr.value(sj_precios,AM2.precioEnvioTransportista) if int(precio)<mejorOferta: mejorOferta = int(precio) agenteElegidoContraoferta = agenteTransportista return agenteElegidoContraoferta
def browserDevolucion(): global compras if request.method == 'GET': logger.info('Se muestran todas las Compras') count, counts = getAllCompras() return render_template('devolucion.html', compras=compras, count=count, tam=counts) else: logger.info('Peticon de devolucion') devoluciones = [] for item in request.form.getlist("checkbox"): devoluciones.append(compras[int(item)][0]) g = Graph() content = ECSDI['Devolver_producto_' + str(get_count())] g.add((content, RDF.type, ECSDI.Devolver_producto)) for compra in devoluciones: g.add((compra, RDF.type, ECSDI.Compra)) logger.info('AQUI SI') agenteDevoluciones = get_agent_info(agn.AgenteDevoluciones, AgenteDirectorio, AgenteExternoAsistentePersonal, get_count()) logger.info('AQUI NO') gm = send_message( build_message(g, perf=ACL.request, sender=AgenteExternoAsistentePersonal.uri, receiver=agenteDevoluciones.uri, msgcnt=get_count(), content=content), agenteDevoluciones.address) subject = gm.value(predicate=RDF.type, object=ECSDI.Info_transporte) transportista = gm.value(subject=subject, predicate=ECSDI.Nombre_transportista) logger.info(transportista) return render_template('finalDevolucion.html', transportista=transportista)
def pagarTiendaExterna(req, content): global mss_cnt mss_cnt = mss_cnt + 1 logging.info("Se empezará a realizar el pago a la tienda externa") cuenta_bancaria = req.value(content, agn.cuenta_bancaria) precio = req.value(content, agn.precio) nombreProd = req.value(content, agn.nombre_prod) AgenteExtEntidadBancaria = Pagador.directory_search(DirectoryAgent, agn.AgenteExtEntidadBancaria) gCobrarP = Graph() cobrarP = agn['pagar_tienda_externa' + str(mss_cnt)] gCobrarP.add((cobrarP, RDF.type, Literal('PagarTiendaExterna'))) gCobrarP.add((cobrarP, agn.cuenta_bancaria, Literal(cuenta_bancaria))) gCobrarP.add((cobrarP, agn.precio, Literal(precio))) gCobrarP.add((cobrarP, agn.nombre_prod, Literal(nombreProd))) message = build_message( gCobrarP, perf=Literal('request'), sender=Pagador.uri, receiver=AgenteExtEntidadBancaria.uri, msgcnt=mss_cnt, content=cobrarP ) response = send_message(message, AgenteExtEntidadBancaria.address) respuesta_cobro = "" for item in response.subjects(RDF.type, Literal('PagoRealizado')): for cobroRelalizado in response.objects(item, agn.respuesta): respuesta_cobro = str(cobroRelalizado) logging.info(respuesta_cobro) gRespuestaCobro = Graph() RespuestaCobro = agn['RespuestaPago' + str(mss_cnt)] gRespuestaCobro.add((RespuestaCobro, RDF.type, Literal('RespuestaPago'))) gRespuestaCobro.add((RespuestaCobro, agn.respuesta_cobro, Literal(respuesta_cobro))) return gRespuestaCobro.serialize(format='xml')
def notificar_envio_tienda_externa(req, content): global mss_cnt mss_cnt = mss_cnt + 1 tienda = req.value(content, agn.tienda) nombreProd = req.value(content, agn.nombre_prod) logging.info("Se informará a la tienda " + str(tienda) + " sobre el enviamento del producto " + str(nombreProd)) peso = req.value(content, agn.peso) cp = req.value(content, agn.cp) direccion = req.value(content, agn.direccion) prioridad_envio = req.value(content, agn.prioridad_envio) TiendaExterna = ComunicadorExterno.directory_search( DirectoryAgent, agn.AgenteExtTiendaExterna) gEnvio = Graph() envio = agn['envio_tienda_externa' + str(mss_cnt)] gEnvio.add((envio, RDF.type, Literal('EnvioTiendaExterna'))) gEnvio.add((envio, agn.nombre_prod, Literal(nombreProd))) gEnvio.add((envio, agn.peso, Literal(peso))) gEnvio.add((envio, agn.cp, Literal(cp))) gEnvio.add((envio, agn.direccion, Literal(direccion))) gEnvio.add((envio, agn.prioridad_envio, Literal(prioridad_envio))) message = build_message(gEnvio, perf=Literal('request'), sender=ComunicadorExterno.uri, receiver=TiendaExterna.uri, msgcnt=mss_cnt, content=envio) send_message(message, TiendaExterna.address) return Graph().serialize(format='xml')
def directory_search_message(type): """ Busca en el servicio de registro mandando un mensaje de request con una accion Seach del servicio de directorio Podria ser mas adecuado mandar un query-ref y una descripcion de registo con variables :param type: :return: """ global mss_cnt logger.info('Buscamos en el servicio de registro') gmess = Graph() gmess.bind('foaf', FOAF) gmess.bind('dso', DSO) reg_obj = agn[AgentePersonal.name + '-search'] gmess.add((reg_obj, RDF.type, DSO.Search)) gmess.add((reg_obj, DSO.AgentType, type)) msg = build_message(gmess, perf=ACL.request, sender=AgentePersonal.uri, receiver=DirectoryAgent.uri, content=reg_obj, msgcnt=mss_cnt) gr = send_message(msg, DirectoryAgent.address) mss_cnt += 1 logger.info('Recibimos informacion del agente') return gr
def directory_search_message(type): """ Busca en el servicio de registro mandando un mensaje de request con una accion Seach del servicio de directorio Podria ser mas adecuado mandar un query-ref y una descripcion de registo con variables :param type: :return: """ logger.info('Buscamos en el servicio de registro') gmess = Graph() gmess.bind('foaf', FOAF) gmess.bind('dso', DSO) reg_obj = agn[AgentClient.name + '-search'] gmess.add((reg_obj, RDF.type, DSO.Search)) gmess.add((reg_obj, DSO.AgentType, type)) msg = build_message(gmess, perf=ACL.request, sender=AgentClient.uri, receiver=DirectoryAgent.uri, content=reg_obj, msgcnt=get_count()) gr = send_message(msg, DirectoryAgent.address) logger.info('Recibimos informacion del agente') return gr
def agentbehavior1(cola): """ Un comportamiento del agente :return: """ global mss_cnt logger.info('Nos registramos en el servicio de registro') register_message(DSO.AgenteLogistico, AgenteLogistico, DirectoryAgent, mss_cnt) fin = False while not fin: while cola.empty(): pass gmess = cola.get() if gmess == 0: fin = True else: agenteVendedorExterno = directory_search_agent( DSO.AgenteVendedorExterno, AgenteLogistico, DirectoryAgent, mss_cnt)[0] content = gmess.value(predicate=RDF.type, object=AM2.Avisar_vendedor_externo_envio) grm = build_message(gmess, perf=ACL.request, sender=AgenteLogistico.uri, receiver=agenteVendedorExterno.uri, content=content, msgcnt=mss_cnt) send_message(grm, agenteVendedorExterno.address) logger.info( 'Se ha notificado al vendedor externo para que se encargue del envio' )
def directory_search(self, DirectoryAgent, type): global mss_cnt logging.info('Buscamos en el servicio de registro') gmess = Graph() gmess.bind('foaf', FOAF) gmess.bind('dso', DSO) reg_obj = agn[self.name + '-search'] gmess.add((reg_obj, RDF.type, DSO.Search)) gmess.add((reg_obj, DSO.AgentType, type)) msg = build_message(gmess, perf=ACL.request, sender=self.uri, receiver=DirectoryAgent.uri, content=reg_obj, msgcnt=mss_cnt) gr = send_message(msg, DirectoryAgent.address) mss_cnt += 1 logging.info('Recibimos informacion del agente') content = get_message_properties(gr)['content'] address = gr.value(subject=content, predicate=DSO.Address) uri = gr.value(subject=content, predicate=DSO.Uri) name = gr.value(subject=content, predicate=DSO.Name) return Agent(name, uri, address, None)
def buscar_desplazamiento(ciudadNombre='Barcelona'): # Creamos el contenido content = ECSDI['peticion_de_desplazamiento' + str(get_count())] # Creamos los objetos necesarios para las tripletas del grafo ciudadOrigen = ECSDI['ciudadOrigen' + str(get_count())] ciudadDestino = ECSDI['ciudadDestino' + str(get_count())] # Creamos el grafo con las tripletas grafo = Graph() grafo.add((ciudadOrigen, RDF.type, ECSDI.ciudadOrigen)) grafo.add((ciudadDestino, RDF.type, ECSDI.ciudadOrigen)) grafo.add((content, RDF.type, ECSDI.peticion_de_desplazamiento)) # Preguntamos por el agente que necesitamos agente_desplazamiento = get_agent_info( agn.AgenteObtenedorDeOfertasDeDesplazamiento, DirectoryAgent, AgenteProcesador, get_count()) # Enviamos el mensaje gr = send_message( build_message(grafo, perf=ACL.request, sender=AgenteProcesador.uri, receiver=agente_desplazamiento.uri, msgcnt=get_count(), content=content), agente_desplazamiento.address) # Retornamos el grafo respuesta del mensaje return gr
def buscar_actividades(type): # type = ludica/festiva/cultural # Creamos el contenido content = ECSDI['peticion_de_actividades' + str(get_count())] # Creamos los objetos necesarios para las tripletas del grafo tipo = ECSDI['tipoActividad' + str(get_count())] # Creamos el grafo con las tripletas grafo = Graph() grafo.add((tipo, RDF.type, ECSDI.ciudadOrigen)) grafo.add((content, RDF.type, ECSDI.peticion_de_actividades)) # Preguntamos por el agente que necesitamos agente_actividades = get_agent_info( agn.AgenteObtenedorDeOfertasDeActividades, DirectoryAgent, AgenteProcesador, get_count()) # Enviamos el mensaje gr = send_message( build_message(grafo, perf=ACL.request, sender=AgenteProcesador.uri, receiver=agente_actividades.uri, msgcnt=get_count(), content=content), agente_actividades.address) # Retornamos el grafo respuesta del mensaje return gr
def register_message(): """ Envia un mensaje de registro al servicio de registro usando una performativa Request y una accion Register del servicio de directorio :param gmess: :return: """ global mss_cnt gmess = Graph() # Construimos el mensaje de registro gmess.bind('foaf', FOAF) gmess.bind('dso', DSO) reg_obj = agn[InfoAgent.name+'-Register'] gmess.add((reg_obj, RDF.type, DSO.Register)) gmess.add((reg_obj, DSO.Uri, InfoAgent.uri)) gmess.add((reg_obj, FOAF.Name, Literal(InfoAgent.name))) gmess.add((reg_obj, DSO.Address, Literal(InfoAgent.address))) gmess.add((reg_obj, DSO.AgentType, DSO.HotelsAgent)) # Lo metemos en un envoltorio FIPA-ACL y lo enviamos gr = send_message( build_message(gmess, perf= ACL.request, sender= InfoAgent.uri, receiver= AgentDirectori.uri, content= reg_obj, msgcnt= mss_cnt), AgentDirectori.address) mss_cnt += 1 return gr
def cobrar(req, content): global mss_cnt mss_cnt = mss_cnt + 1 logging.info("Se empezará a cobrar el pedido") tarjeta_bancaria = req.value(content, agn.tarjeta_bancaria) precio_total = req.value(content, agn.precio_total) AgenteExtEntidadBancaria = Pagador.directory_search(DirectoryAgent, agn.AgenteExtEntidadBancaria) gCobrarP = Graph() cobrarP = agn['cobrarP_' + str(mss_cnt)] gCobrarP.add((cobrarP, RDF.type, Literal('CobrarP'))) gCobrarP.add((cobrarP, agn.tarjeta_bancaria, Literal(tarjeta_bancaria))) gCobrarP.add((cobrarP, agn.precio_total, Literal(precio_total))) message = build_message( gCobrarP, perf=Literal('request'), sender=Pagador.uri, receiver=AgenteExtEntidadBancaria.uri, msgcnt=mss_cnt, content=cobrarP ) response = send_message(message, AgenteExtEntidadBancaria.address) respuesta_cobro = "" for item in response.subjects(RDF.type, Literal('CobroRealizado')): for cobroRelalizado in response.objects(item, agn.respuesta): respuesta_cobro = str(cobroRelalizado) logging.info(respuesta_cobro) gRespuestaCobro = Graph() RespuestaCobro = agn['RespuestaCobro_' + str(mss_cnt)] gRespuestaCobro.add((RespuestaCobro, RDF.type, Literal('RespuestaCobro'))) gRespuestaCobro.add((RespuestaCobro, agn.respuesta_cobro, Literal(respuesta_cobro))) return gRespuestaCobro.serialize(format='xml')
def infoagent_search_message(addr, ragn_uri): """ Envia una accion a un agente de informacion """ global mss_cnt logger.info('Hacemos una peticion al servicio de informacion') gmess = Graph() # Supuesta ontologia de acciones de agentes de informacion IAA = Namespace('IAActions') gmess.bind('foaf', FOAF) gmess.bind('iaa', IAA) reg_obj = agn[AgentePersonal.name + '-info-search'] gmess.add((reg_obj, RDF.type, IAA.Search)) msg = build_message(gmess, perf=ACL.request, sender=AgentePersonal.uri, receiver=ragn_uri, msgcnt=mss_cnt) gr = send_message(msg, addr) mss_cnt += 1 logger.info('Recibimos respuesta a la peticion al servicio de informacion') return gr
def infoagent_search_message(addr, ragn_uri): """ Envia una accion a un agente de informacion """ global mss_cnt logger.info('Hacemos una peticion al servicio de informacion') gmess = Graph() # Supuesta ontologia de acciones de agentes de informacion IAA = Namespace('IAActions') gmess.bind('foaf', FOAF) gmess.bind('iaa', IAA) reg_obj = agn[AgenteCliente.name + '-info-search'] gmess.add((reg_obj, RDF.type, IAA.Search)) msg = build_message(gmess, perf=ACL.request, sender=AgenteCliente.uri, receiver=ragn_uri, msgcnt=mss_cnt) gr = send_message(msg, addr) mss_cnt += 1 logger.info('Recibimos respuesta a la peticion al servicio de informacion') return gr
def register(): global mss_cnt logger.info("Nos registramos") gmess = Graph() gmess.bind('foaf', FOAF) gmess.bind('dso', DSO) reg_obj = agn[AgenteNegociadorTiendasExternas.name + '-Register'] gmess.add((reg_obj, RDF.type, DSO.Register)) gmess.add((reg_obj, DSO.Uri, AgenteNegociadorTiendasExternas.uri)) gmess.add( (reg_obj, FOAF.name, Literal(AgenteNegociadorTiendasExternas.name))) gmess.add((reg_obj, DSO.Address, Literal(AgenteNegociadorTiendasExternas.address))) gmess.add((reg_obj, DSO.AgentType, agn.AgenteNegociadorTiendasExternas)) gr = send_message( build_message(gmess, perf=ACL.request, sender=AgenteNegociadorTiendasExternas.uri, receiver=AgenteDirectorio.uri, content=reg_obj, msgcnt=mss_cnt), AgenteDirectorio.address) mss_cnt += 1 return gr
def proponer_oferta(oferta): global mss_cnt transportista = AgentUtil.Agents.AgenteTransportista if str(oferta.transportista) == 'SEUR' else \ AgentUtil.Agents.AgenteTransportista2 gmess = Graph() gmess.bind('ab', AB) nuevo_precio = float(oferta.precio) - (float(oferta.precio) / 10.0) content = AB[AgentUtil.Agents.AgenteCentroLogistico.name + '-proponer-oferta'] gmess.add((content, AB.id, Literal(oferta.id))) gmess.add((content, AB.precio, Literal(nuevo_precio))) logger.info("[#] Proponiendo oferta a %s y bajando el precio de %s a %s" % (oferta.transportista, oferta.precio, nuevo_precio)) msg = build_message(gmess, perf=ACL.propose, sender=AgentUtil.Agents.AgenteCentroLogistico.uri, receiver=transportista.uri, content=content, msgcnt=mss_cnt) res = send_message(msg, transportista.address) mss_cnt += 1
def comunicacion(): """ Entrypoint de comunicacion """ global dsGraph logger.info('Peticion de nuevo producto externo recivida') message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) gr = None if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgenteNegociadorTiendasExternas.uri, msgcnt=get_count()) else: # Llega una metodologia if msgdic['performative'] == ACL.inform: content = msgdic['content'] metodologiaDePago = gm.value(subject=content, predicate=ECSDI.Metodologia_de_pago) tiendaExterna = msgdic['sender'] gr = añadirMetodologiaDePago(tiendaExterna, metodologiaDePago) # Una tienda externa quiere añadir un producto a nuestra tienda elif msgdic['performative'] == ACL.request: tiendaOrigen = msgdic['sender'] anadirProductosTiendaExterna(gm, tiendaOrigen) gr = build_message(Graph(), perf=ACL['inform'], sender=AgenteNegociadorTiendasExternas.uri, msgcnt=get_count(), receiver=tiendaOrigen) logger.info('Respondemos a la peticion') return gr.serialize(format='xml'), 200
def communication(): """ Communication Entrypoint """ logger.info('Peticion de informacion recibida') global dsGraph message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) gr = None if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=PlannerAgent.uri, msgcnt=get_count()) else: # Obtenemos la performativa if msgdic['performative'] != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=DirectoryAgent.uri, msgcnt=get_count()) else: # Extraemos el objeto del contenido que ha de ser una accion de la ontologia # de registro content = msgdic['content'] # Averiguamos el tipo de la accion accion = gm.value(subject=content, predicate=RDF.type) if accion == ECSDI.peticion_de_plan: logger.info("Estoy en else") logger.info(accion) logger.info('Respondemos a la peticion') serialize = gr.serialize(format='xml') return serialize, 200
def comunicacion(): """ Entrypoint de comunicacion del agente """ global dsgraph global mss_cnt #Extraemos el mensaje y creamos un grafo con el message= request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) # Comprobamos que sea un mensaje FIPA ACL if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'],AgentSistemanfoAgent.uri, msgcnt=mss_cnt) else: # Obtenemos la performativa perf = msgdic['performative'] if perf != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'],AgentSistemanfoAgent.uri, msgcnt=mss_cnt) else: #Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente # de registro # Averiguamos el tipo de la accion if 'content' in msgdic: content = msgdic['content'] accion = gm.value(subject=content, predicate= RDF.type) # Aqui realizariamos lo que pide la accion gp = crear_paquet(gm) # Por ahora simplemente retornamos un Inform-done gr = build_message(gp, ACL['inform-done'], sender=AgentSistema.uri, msgcnt=mss_cnt, receiver=msgdic['sender'],) mss_cnt += 1 return gr.serialize(format='xml')
def comunicacion(): global ultimo_informe_recibido message = request.args['content'] #cogo el contenido enviado grafo = Graph() logger.info('--Envian una comunicacion') grafo.parse(data=message) logger.info('--Envian una comunicacion') message_properties = get_message_properties(grafo) resultado_comunicacion = None if message_properties is None: #respondemos que no hemos entendido el mensaje resultado_comunicacion = build_message(Graph(), ACL['not-understood'], sender=AgenteUsuario.uri, msgcnt=get_message_count()) else: #obtenemos la performativa if message_properties['performative'] != ACL.request: #Si no es un request, respondemos que no hemos entendido el mensaje resultado_comunicacion = build_message(Graph(), ACL['not-understood'], sender=AgenteUsuario.uri, msgcnt=get_message_count()) else: #Extraemos el contenido que ha de ser una accion de la ontologia contenido = message_properties['content'] accion = grafo.value(subject=contenido, predicate=RDF.type) logger.info("La accion es: " + accion) #si la acción es de tipo tranferencia empezamos if accion == ECSDIAmazon.Informar: logger.info("Ya apunto de finalizar") # thread = Thread(target=enviarVenta, args=(contenido,grafo)) # thread.start() ultimo_informe_recibido = grafo graf = Graph() mensaje = ECSDIAmazon["Respuesta"+ str(get_message_count())] graf.add((mensaje,RDF.type, ECSDIAmazon.Respuesta)) graf.add((mensaje,ECSDIAmazon.Mensaje,Literal("OK",datatype=XSD.string))) resultado_comunicacion = graf logger.info("Antes de serializar la respuesta") serialize = resultado_comunicacion.serialize(format="xml") return serialize, 200
def comunicacion(): """ Entrypoint de comunicacion """ logger.info('Peticion de plan recibida') global dsGraph message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) gr = None if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlojamiento.uri, msgcnt=get_count()) else: # Obtenemos la performativa if msgdic['performative'] != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=DirectoryAgent.uri, msgcnt=get_count()) else: # Extraemos el objeto del contenido que ha de ser una accion de la ontologia # de registro content = msgdic['content'] # Averiguamos el tipo de la accion accion = gm.value(subject=content, predicate=RDF.type) # Accion de busqueda if accion == ECSDI.Peticion_Alojamiento: gr = findHoteles() logger.info('Api usada') serialize = gr.serialize(format='xml') logger.info("bye bye") return serialize, 200
def browser_purchase(): global mss_cnt gmess = Graph() msg = build_message(gmess, perf=ACL.inform, sender=AgentUtil.Agents.AgenteVendedor.uri, receiver=AgentUtil.Agents.AgenteCentroLogistico.uri, msgcnt=mss_cnt) gr = send_message(msg, AgentUtil.Agents.AgenteCentroLogistico.address) mss_cnt += 1 return gr
def demanar_paquet (gmess): """ Envia la peticio d'un paquet vacances amb les preferencies de l'usuari """ global mss_cnt msg = build_message(gmess, perf=ACL.request, sender=AgentUsuari.uri, receiver=AgentSistema.uri, msgcnt=mss_cnt) gr = send_message(msg, AgentSistema.address) mss_cnt += 1 return gr
def communication(): message = request.args['content'] #cogo el contenido enviado grafo = Graph() logger.info('--Envian una comunicacion') grafo.parse(data=message) logger.info('--Envian una comunicacion') message_properties = get_message_properties(grafo) resultado_comunicacion = None if message_properties is None: # Respondemos que no hemos entendido el mensaje resultado_comunicacion = build_message( Graph(), ACL['not-understood'], sender=AgenteGestorDeProductos.uri, msgcnt=get_message_count()) else: # Obtenemos la performativa if message_properties['performative'] != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje resultado_comunicacion = build_message(Graph(), ACL['not-understood'], sender=DirectoryAgent.uri, msgcnt=get_message_count()) else: # Extraemos el contenido que ha de ser una accion de la ontologia definida en Protege contenido = message_properties['content'] accion = grafo.value(subject=contenido, predicate=RDF.type) logger.info("La accion es: " + accion) # Si la acción es de tipo busqueda empezamos if accion == ECSDIAmazon.Buscar_productos: resultado_comunicacion = buscar_productos(contenido, grafo) elif accion == ECSDIAmazon.Anadir_producto: resultado_comunicacion = anadir_producto(grafo) logger.info('Antes de serializar la respuesta') serialize = resultado_comunicacion return serialize, 200
def process_register(): # Si la hay extraemos el nombre del agente (FOAF.Name), el URI del agente # su direccion y su tipo agn_add = gm.value(subject=content, predicate=DSO.Address) agn_name = gm.value(subject=content, predicate=FOAF.Name) agn_uri = gm.value(subject=content, predicate=DSO.Uri) agn_type = gm.value(subject=content, predicate=DSO.AgentType) # Añadimos la informacion en el grafo de registro vinculandola a la URI # del agente y registrandola como tipo FOAF.Agent dsgraph.add((agn_uri, RDF.type, FOAF.Agent)) dsgraph.add((agn_uri, FOAF.name, agn_name)) dsgraph.add((agn_uri, DSO.Address, agn_add)) dsgraph.add((agn_uri, DSO.AgentType, agn_type)) # Generamos un mensaje de respuesta return build_message(Graph(), ACL.confirm, sender=AgentDirectori.uri, receiver=agn_uri, msgcnt=mss_cnt)
def test(): gmess = Graph() # Construimos el mensaje de registro gmess.bind('foaf', FOAF) gmess.bind('dso', DSO) reg_obj = agn[InfoAgent.name + '-Register'] gmess.add((reg_obj, RDF.type, DSO.Register)) gmess.add((reg_obj, DSO.Uri, InfoAgent.uri)) gmess.add((reg_obj, FOAF.Name, Literal(InfoAgent.name))) gmess.add((reg_obj, DSO.Address, Literal(InfoAgent.address))) gmess.add((reg_obj, DSO.AgentType, DSO.HotelsAgent)) # Lo metemos en un envoltorio FIPA-ACL y lo enviamos gr = send_message( build_message(gmess, perf=ACL.request, sender=InfoAgent.uri, receiver=DirectoryAgent.uri, content=reg_obj, msgcnt=mss_cnt), DirectoryAgent.address)
def infoagent_search_message(addr, ragn_uri, gmess): """ Envia una accion a un agente de informacion """ global mss_cnt """gmess = Graph() # Supuesta ontologia de acciones de agentes de informacion IAA = Namespace('IAActions') gmess.bind('foaf', FOAF) gmess.bind('iaa', IAA) reg_obj = agn[AgentSistema.name+'-info-search'] gmess.add((reg_obj, RDF.type, IAA.Search))""" msg = build_message(gmess, perf=ACL.request, sender=AgentSistema.uri, receiver=ragn_uri, msgcnt=mss_cnt) gr = send_message(msg, addr) mss_cnt += 1 return gr
def comunicacion(): """ Entrypoint de comunicacion del agente Simplementet retorna un objeto fijo que representa una respuesta a una busqueda de hotel Asumimos que se reciben siempre acciones que se refieren a lo que puede hacer el agente (buscar con ciertas restricciones, reservar) Las acciones se mandan siempre con un Request Prodriamos resolver las busquedas usando una performativa de Query-ref """ res_obj= agn['Planificador-responde'] gr = Graph() gr.add((res_obj, DSO.AddressList, Literal(cont))) gr = build_message(gr, ACL.inform, sender=AgentBuscador.uri, content=res_obj, msgcnt=mss_cnt ) resp = gr.serialize(format='xml') return resp
def comunicacion(): """ Entrypoint de comunicacion """ global dsgraph global mss_cnt print 'Peticion de informacion recibida\n' # Extraemos el mensaje y creamos un grafo con el message = request.args['content'] print "Mensaje extraído\n" # VERBOSE print message print "\n\n" gm = Graph() gm.parse(data=message) print 'Grafo creado con el mensaje' msgdic = get_message_properties(gm) # Comprobamos que sea un mensaje FIPA ACL if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgentePlanificador.uri, msgcnt=mss_cnt) print 'El mensaje no era un FIPA ACL' else: # Obtenemos la performativa perf = msgdic['performative'] if perf != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgentePlanificador.uri, msgcnt=mss_cnt) else: # Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente # de registro # Averiguamos el tipo de la accion # if 'content' in msgdic: # content = msgdic['content'] # accion = gm.value(subject=content, predicate=RDF.type) # Apartir de aqui tenemos que obtener parametro desde dialog y luego comunicar con buscador ########################################################### # Parsear los parametros de Dialog print "Parsear los parametros de Dialog" ############################################################# peticion = myns_pet["Dialogador-pide-paquete"] parametros = gm.triples((peticion, None, None)) # VERBOSE print "Parametros: " print parametros actv = myns_pet.actividad ########################################################### # Comunicar con buscador print "Los parametros recibidos" ############################################################# # departureDate="2015-08-20" # returnDate="2015-08-30" # maxPrice=500 # originCity="Amsterdam" # destinationCity="Barcelona" # propertyCategory=1 originCity = gm.value(subject= peticion, predicate= myns_atr.originCity) #gmess.add((actv, myns_atr.lugar, origin)) # VERBOSE print "originCity: " print originCity departureDate = gm.value(subject= peticion, predicate= myns_atr.departureDate) #gmess.add((actv, myns_atr.lugar, departureDate)) # VERBOSE print "departureDate: " print departureDate returnDate = gm.value(subject= peticion, predicate= myns_atr.returnDate) #gmess.add((actv, myns_atr.lugar, returnDate)) # VERBOSE print "returnDate: " print returnDate maxPrice = float(gm.value(subject= peticion, predicate= myns_atr.maxPrice)) #gmess.add((actv, myns_atr.lugar, maxPrice)) # VERBOSE print "maxPrice: " print maxPrice propertyCategory = gm.value(subject= peticion, predicate= myns_atr.propertyCategory) #gmess.add((actv, myns_atr.lugar, numberOfStars)) # VERBOSE print "propertyCategory: " print propertyCategory actividades = [] actividadesInt = gm.triples((None, myns_atr.tipo, None)) for s,p, o in actividadesInt: actividades.append(o) activity= gm.value(subject= peticion, predicate= myns_atr.activities) print "activity: " print activity actividades.append(activity) destinationCity=gm.value(subject= peticion, predicate= myns_atr.destinationCity) print "destinationCity: " print destinationCity # Graph para buscador gmess = Graph() gmess.bind('myns_pet', myns_pet) gmess.bind('myns_atr', myns_atr) ########################################################### # Comunicar con buscador # print "Los parametros hardcoreado" ############################################################# # actividades= [types.TYPE_MOVIE_THEATER, types.TYPE_CASINO, types.TYPE_MUSEUM] # departureDate="2015-08-20" # returnDate="2015-08-30" # maxPrice=500 # originCity="Amsterdam" # destinationCity="Barcelona" # propertyCategory=1 print departureDate ########################################################### # Mejorar preferencia de busqueda print "Mejorar preferencia de busqueda" ############################################################# ########################################################### # Comunicar con buscador print "Iniciar la comunicaion con buscador" ############################################################# # Hago bind de las ontologias que voy a usar en el grafo # Estas ontologias estan definidas arriba (abajo de los imports) # Son las de peticiones y atributos (para los predicados de la tripleta) # Sujeto de la tripleta: http://my.namespace.org/peticiones/actividad # O sea, el mensaje sera una peticion de actividad # El buscador tendra que ver que tipo de peticion es ########################################################### # Comunicar con buscador print "Añadir parametros de actividad" ############################################################# # Paso los parametros de busqueda de actividad en el grafo busqueda = myns_pet.busqueda i = 0 for a in actividades: i+= 1 actv = "actividad" + str(i) gmess.add((busqueda, myns_par.actividad, myns_act.actv)) gmess.add((myns_act.actv, myns_atr.tipo, Literal(a))) i+= 1 actv = "actividad" + str(i) gmess.add((busqueda, myns_par.actividad, myns_act.actv)) gmess.add((myns_act.actv, myns_atr.tipo, Literal('restaurant'))) ########################################################### # Comunicar con buscador print "Añadir parametros de vuelo" ############################################################# gmess.add((busqueda, myns_par.departureDate, Literal(departureDate))) gmess.add((busqueda, myns_par.returnDate, Literal(returnDate))) gmess.add((busqueda, myns_par.maxPrice, Literal(maxPrice/3))) ########################################################### # Comunicar con buscador print "Añadir parametros de hotel" ############################################################# hotel = myns_pet.hotel gmess.add((busqueda, myns_par.originCity, Literal(originCity))) gmess.add((busqueda, myns_par.destinationCity, Literal(destinationCity))) gmess.add((busqueda, myns_par.propertyCategory, Literal(propertyCategory))) # Uri asociada al mensaje sera: http://www.agentes.org#Planificador-pide-actividades res_obj= agn['Planificador-pide-datos'] # Construyo el grafo y lo mando (ver los metodos send_message y build_message # en ACLMessages para entender mejor los parametros) print "INFO AgentePlanificador=> Sending request to AgenteBuscador\n" gr = send_message(build_message(gmess, perf=ACL.request, sender=AgentePlanificador.uri, receiver=AgenteBuscador.uri, content=res_obj, msgcnt=mss_cnt ), AgenteBuscador.address) print "Respuesta de busqueda recibida\n" # for s, p, o in grep: # print 's: ' + s # print 'p: ' + p # print 'o: ' + o.encode('utf-8') # print '\n' ########################################################### # Calcular paquete print "Calcular paquete" ############################################################# grep = Graph() ########################################################### # Calcular paquete print "Calcular Vuelos" ############################################################# gvuelo = Graph() for s,p,o in gr.triples((None, myns_atr.esUn, myns.viaje)): gvuelo += gr.triples((s, None, None) ) gvueloid = gvuelo.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?cuesta WHERE{ ?a myns_atr:cuesta ?cuesta . FILTER(str(?cuesta) != "") } ORDER BY (?cuesta) LIMIT 1 """) Aid = [] cuestaVuelo = 0 for s, c in gvueloid: print s Aid.append(s) cuestaVuelo = float(c[3:]) maxPrice -= cuestaVuelo grep += gvuelo.triples((Aid[0], None, None)) idgo = gr.value(subject= Aid[0], predicate= myns_atr.ida) idback = gr.value(subject= Aid[0], predicate= myns_atr.vuelta) grep += gr.triples((idgo,None, None)) grep += gr.triples((idback, None, None)) ########################################################### # Calcular paquete print "Calcular Hotel" ############################################################# ghotel = Graph() for s,p,o in gr.triples((None, myns_atr.esUn, myns.hotel)): ghotel += gr.triples((s, None, None) ) ghotelid = ghotel.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?cuesta WHERE{ ?a myns_atr:rating ?ratin . ?a myns_atr:cuesta ?cuesta . FILTER(str(?ratin) != "" && str(?cuesta) != "") } ORDER BY DESC(?ratin) ?cuesta LIMIT 1 """) Aid = [] cuestaHotel = 0 for s, c in ghotelid: Aid.append(s) cuestaHotel = float(c) maxPrice -= cuestaHotel grep += ghotel.triples((Aid[0], None, None)) #Actividades ########################################################### # Calcular paquete print "Calcular Actividades" ############################################################# gactividad = Graph() for s,p,o in gr.triples((None, myns_atr.esUn, myns.actividad)): gactividad += gr.triples((s, None, None) ) grestaurante = gactividad.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?ratin ?tip WHERE{ ?a myns_atr:rating ?ratin . ?a myns_atr:tipo ?tip FILTER(?tip = "restaurant") } ORDER BY DESC(?ratin) """) restaurant = [] for g, r, t in grestaurante: restaurant.append(g) gnight = gactividad.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?ratin ?tip WHERE{ ?a myns_atr:rating ?ratin . ?a myns_atr:tipo ?tip FILTER (?tip = "night_club" || ?tip = "bar" || ?tip = "casino" ) } ORDER BY DESC(?ratin) """) night = [] for g, r, t in gnight: night.append(g) print len(night) gday = gactividad.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?ratin ?tip WHERE{ ?a myns_atr:rating ?ratin . ?a myns_atr:tipo ?tip } ORDER BY DESC(?ratin) """) daylist = [] for g, r, t in gday: daylist.append(g) ########################################################### # Escoger Actividades print "Escoger Actividades" ############################################################# day = datetime.strptime(departureDate, '%Y-%m-%d') cday = 0 cnight = 0 cres = 0 rd = datetime.strptime(returnDate, '%Y-%m-%d') while day <= rd: # cada dia grfdata = myns_data.day if len(daylist) != 0: # manana grep.add((grfdata, myns_data.manana, daylist[cday%len(daylist)])) grep += gactividad.triples((daylist[cday%len(daylist)], None, None)) cday += 1; grep.add((grfdata, myns_data.tarde, daylist[cday%len(daylist)])) grep += gactividad.triples((daylist[cday%len(daylist)], None, None)) cday += 1; # comida grep.add((grfdata, myns_data.comida, restaurant[cres%len(restaurant)])) grep += gactividad.triples((restaurant[cres%len(restaurant)], None, None)) cres += 1; # cena grep.add((grfdata, myns_data.cena, restaurant[cres%len(restaurant)])) grep += gactividad.triples((restaurant[cres%len(restaurant)], None, None)) cres += 1; # noche if len(night) != 0: grep.add((grfdata, myns_data.noche, night[cnight%len(night)])) grep += gactividad.triples((night[cnight%len(night)], None, None)) cnight += 1; day = day + timedelta(days=1) ########################################################### # Construir mensage de repuesta print "Construir mensage de repuesta" ############################################################# # for s, p, o in grep: # print 's: ' + s # print 'p: ' + p # print 'o: ' + o.encode('utf-8') # print '\n' mss_cnt += 1 print 'Respondemos a la peticion\n' ########################################################### # Construir mensage de repuesta print "Retornar repuesta" ############################################################# return grep.serialize(format='xml')
def comu(): global mss_cnt # Graph para buscador gmess = Graph() gmess.bind('myns_pet', myns_pet) gmess.bind('myns_atr', myns_atr) ########################################################### # Comunicar con buscador print "Los parametros hardcoreado" ############################################################# destination = "Madrid, Spain" actividades= [types.TYPE_MOVIE_THEATER, types.TYPE_CASINO, types.TYPE_MUSEUM] radius = 20000 departureDate="2015-08-20" returnDate="2015-08-30" maxPrice=500 originCity="Amsterdam" destinationCity="Barcelona" destinationCountry="Spain" searchRadius=2 propertyCategory=1 print departureDate ########################################################### # Mejorar preferencia de busqueda print "Mejorar preferencia de busqueda" ############################################################# ########################################################### # Comunicar con buscador print "Iniciar la comunicaion con buscador" ############################################################# # Hago bind de las ontologias que voy a usar en el grafo # Estas ontologias estan definidas arriba (abajo de los imports) # Son las de peticiones y atributos (para los predicados de la tripleta) # Sujeto de la tripleta: http://my.namespace.org/peticiones/actividad # O sea, el mensaje sera una peticion de actividad # El buscador tendra que ver que tipo de peticion es ########################################################### # Comunicar con buscador print "Añadir parametros de actividad" ############################################################# # Paso los parametros de busqueda de actividad en el grafo busqueda = myns_pet.busqueda i = 0 for a in actividades: i+= 1 actv = "actividad" + str(i) gmess.add((busqueda, myns_par.actividad, myns_act.actv)) gmess.add((myns_act.actv, myns_atr.tipo, Literal(a))) i+= 1 actv = "actividad" + str(i) gmess.add((busqueda, myns_par.actividad, myns_act.actv)) gmess.add((myns_act.actv, myns_atr.tipo, Literal('restaurant'))) ########################################################### # Comunicar con buscador print "Añadir parametros de vuelo" ############################################################# gmess.add((busqueda, myns_par.departureDate, Literal(departureDate))) gmess.add((busqueda, myns_par.returnDate, Literal(returnDate))) gmess.add((busqueda, myns_par.maxPrice, Literal(maxPrice/3))) ########################################################### # Comunicar con buscador print "Añadir parametros de hotel" ############################################################# hotel = myns_pet.hotel gmess.add((busqueda, myns_par.originCity, Literal(originCity))) gmess.add((busqueda, myns_par.destinationCity, Literal(destinationCity))) gmess.add((busqueda, myns_par.propertyCategory, Literal(propertyCategory))) # Uri asociada al mensaje sera: http://www.agentes.org#Planificador-pide-actividades res_obj= agn['Planificador-pide-datos'] # Construyo el grafo y lo mando (ver los metodos send_message y build_message # en ACLMessages para entender mejor los parametros) print "INFO AgentePlanificador=> Sending request to AgenteBuscador\n" gr = send_message(build_message(gmess, perf=ACL.request, sender=AgentePlanificador.uri, receiver=AgenteBuscador.uri, content=res_obj, msgcnt=mss_cnt ), AgenteBuscador.address) print "Respuesta de busqueda recibida\n" # for s, p, o in grep: # print 's: ' + s # print 'p: ' + p # print 'o: ' + o.encode('utf-8') # print '\n' ########################################################### # Calcular paquete print "Calcular paquete" ############################################################# grep = Graph() ########################################################### # Calcular paquete print "Calcular Vuelos" ############################################################# gvuelo = Graph() for s,p,o in gr.triples((None, myns_atr.esUn, myns.viaje)): gvuelo += gr.triples((s, None, None) ) gvueloid = gvuelo.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?cuesta WHERE{ ?a myns_atr:cuesta ?cuesta . FILTER(str(?cuesta) != "") } ORDER BY (?cuesta) LIMIT 1 """) Aid = [] cuestaVuelo = 0 for s, c in gvueloid: print s Aid.append(s) cuestaVuelo = float(c[3:]) maxPrice -= cuestaVuelo grep += gvuelo.triples((Aid[0], None, None)) ########################################################### # Calcular paquete print "Calcular Hotel" ############################################################# ghotel = Graph() for s,p,o in gr.triples((None, myns_atr.esUn, myns.hotel)): ghotel += gr.triples((s, None, None) ) ghotelid = ghotel.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?cuesta WHERE{ ?a myns_atr:rating ?ratin . ?a myns_atr:cuesta ?cuesta . FILTER(str(?ratin) != "" && str(?cuesta) != "") } ORDER BY DESC(?ratin) ?cuesta LIMIT 1 """) Aid = [] cuestaHotel = 0 for s, c in ghotelid: Aid.append(s) cuestaHotel = float(c) maxPrice -= cuestaHotel grep += ghotel.triples((Aid[0], None, None)) #Actividades ########################################################### # Calcular paquete print "Calcular Actividades" ############################################################# gactividad = Graph() for s,p,o in gr.triples((None, myns_atr.esUn, myns.actividad)): gactividad += gr.triples((s, None, None) ) grestaurante = gactividad.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?ratin ?tip WHERE{ ?a myns_atr:rating ?ratin . ?a myns_atr:tipo ?tip FILTER(?tip = "restaurant") } ORDER BY DESC(?ratin) """) restaurant = [] for g, r, t in grestaurante: restaurant.append(g) gnight = gactividad.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?ratin ?tip WHERE{ ?a myns_atr:rating ?ratin . ?a myns_atr:tipo ?tip FILTER (?tip = "night_club" || ?tip = "bar" || ?tip = "casino" ) } ORDER BY DESC(?ratin) """) night = [] for g, r, t in gnight: night.append(g) print len(night) gday = gactividad.query(""" PREFIX myns_atr: <http://my.namespace.org/atributos/> SELECT DISTINCT ?a ?ratin ?tip WHERE{ ?a myns_atr:rating ?ratin . ?a myns_atr:tipo ?tip } ORDER BY DESC(?ratin) """) daylist = [] for g, r, t in gday: daylist.append(g) ########################################################### # Escoger Actividades print "Escoger Actividades" ############################################################# day = datetime.strptime(departureDate, '%Y-%m-%d') cday = 0 cnight = 0 cres = 0 rd = datetime.strptime(returnDate, '%Y-%m-%d') while day <= rd: # cada dia grfdata = myns_data.day # manana grep.add((grfdata, myns_data.manana, daylist[cday%len(daylist)])) grep += gactividad.triples((daylist[cday%len(daylist)], None, None)) cday += 1; grep.add((grfdata, myns_data.tarde, daylist[cday%len(daylist)])) grep += gactividad.triples((daylist[cday%len(daylist)], None, None)) cday += 1; # comida grep.add((grfdata, myns_data.comida, restaurant[cres%len(restaurant)])) grep += gactividad.triples((restaurant[cres%len(restaurant)], None, None)) cres += 1; # cena grep.add((grfdata, myns_data.cena, restaurant[cres%len(restaurant)])) grep += gactividad.triples((restaurant[cres%len(restaurant)], None, None)) cres += 1; # noche if len(night) != 0: grep.add((grfdata, myns_data.noche, night[cnight%len(night)])) grep += gactividad.triples((night[cnight%len(night)], None, None)) cnight += 1; day = day + timedelta(days=1) ########################################################### # Construir mensage de repuesta print "Construir mensage de repuesta" ############################################################# # for s, p, o in grep: # print 's: ' + s # print 'p: ' + p # print 'o: ' + o.encode('utf-8') # print '\n' mss_cnt += 1 return grep
def comunicacion(): """ Entrypoint de comunicacion del agente Simplementet retorna un objeto fijo que representa una respuesta a una busqueda de hotel Asumimos que se reciben siempre acciones que se refieren a lo que puede hacer el agente (buscar con ciertas restricciones, reservar) Las acciones se mandan siempre con un Request Prodriamos resolver las busquedas usando una performativa de Query-ref """ #global dsgraph #global mss_cnt #logger.info('Peticion de informacion recibida') ## Extraemos el mensaje y creamos un grafo con el #message = request.args['content'] #gm = Graph() #gm.parse(data=message) #msgdic = get_message_properties(gm) ## Comprobamos que sea un mensaje FIPA ACL #if msgdic is None: ## Si no es, respondemos que no hemos entendido el mensaje #gr = build_message(Graph(), ACL['not-understood'], sender=InfoAgent.uri, msgcnt=mss_cnt) #else: ## Obtenemos la performativa #perf = msgdic['performative'] #if perf != ACL.request: ## Si no es un request, respondemos que no hemos entendido el mensaje #gr = build_message(Graph(), ACL['not-understood'], sender=InfoAgent.uri, msgcnt=mss_cnt) #else: ## Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente ## de registro ## Averiguamos el tipo de la accion #if 'content' in msgdic: #content = msgdic['content'] #accion = gm.value(subject=content, predicate=RDF.type) ## Aqui realizariamos lo que pide la accion ## Por ahora simplemente retornamos un Inform-done #gr = build_message(Graph(), #ACL['inform-done'], #sender=InfoAgent.uri, #msgcnt=mss_cnt, #receiver=msgdic['sender'], ) #mss_cnt += 1 #logger.info('Respondemos a la peticion') # gr = build_message(gmess, perf=ACL.request, # sender=AgentePlanificador.uri, # receiver=AgenteBuscador.uri, # content=bus_obj, # msgcnt=mss_cnt), # AgenteBuscador.address) res_obj= agn['Planificador-responde'] gr = Graph() gr.add((res_obj, DSO.AddressList, Literal(cont))) gr = build_message(gr, ACL.inform, sender=AgentBuscador.uri, content=res_obj, msgcnt=mss_cnt ) resp = gr.serialize(format='xml') return resp
def message_dialogador(cityOrigin = "Barcelona", cityDestination = "London", departureDate = datetime.date(2015, 9, 8), returnDate = datetime.date(2015, 9, 20), maxPrice = 500, numberOfStars = 3, actividades = ["Movie", "Casino", "Theater"] ): #Preguntamos al usuario sus preferencias print ('Welcome to Bestrip! The best trip search engine in the world!' + '\n') print ('Please, answer these questions to find your trip!' + '\n') # cityDestination = raw_input ('Where do you want to go?' + '\n') # cityOrigin = raw_input ('Where are you?' + '\n') # departureDate = raw_input ('When do you want to go? (Format : dd/mm/yyyy)' + '\n' ) # returnDate = raw_input ('When do you want to return? (Format : dd/mm/yyyy)' + '\n' ) # maxPrice = raw_input('Which is the maximum price that a trip must have?' + '\n') # numberOfStars = raw_input ('How many stars the hotel must have ?' + '\n') # activities = raw_input ('Tell us about the kind of activities you like! (Format:separate using commas for each preference)' + '\n') # transport = raw_input ('Would you like to use public transport during your trip? (Yes / No)' + '\n') print ('Thank you very much, finding the best trip according to your preferences ... ' + '\n') #cont = city + "#" + departureDate + "#" + returnDate + "#" + maxPrice + "#" + numberOfStars + "#" + activities + "#" + transport gmess = Graph() gmess.bind('myns_pet', myns_pet) gmess.bind('myns_atr', myns_atr) peticion = myns_pet["Dialogador-pide-paquete"] gmess.add((peticion, myns_atr.originCity, Literal(cityOrigin))) gmess.add((peticion, myns_atr.destinationCity, Literal(cityDestination))) gmess.add((peticion, myns_atr.departureDate, Literal(departureDate))) gmess.add((peticion, myns_atr.returnDate, Literal(returnDate))) gmess.add((peticion, myns_atr.maxPrice, Literal(maxPrice))) gmess.add((peticion, myns_atr.propertyCategory, Literal(numberOfStars))) #for a in activities i = 0 for a in actividades: i+= 1 actv = "actividad" + str(i) gmess.add((peticion, myns_atr.actividad, myns_act.actv)) gmess.add((myns_act.actv, myns_atr.tipo, Literal(a))) #gmess.add((peticion, myns_atr.useTransportPublic, Literal(transport))) # # Construimos el mensaje de registro gmess.bind('amo', AMO) bus_obj = agn[AgenteDialog.name + '-Request'] gmess.add((bus_obj, AMO.requestType, Literal('Actividad'))) # Lo metemos en un envoltorio FIPA-ACL y lo enviamos gr = send_message( build_message(gmess, perf=ACL.request, sender=AgenteDialog.uri, receiver=AgentePlanificador.uri, content=bus_obj, msgcnt=mss_cnt), AgentePlanificador.address) return gr
def comunicacion(): """ Entrypoint de comunicacion del agente Simplementet retorna un objeto fijo que representa una respuesta a una busqueda de hotel Asumimos que se reciben siempre acciones que se refieren a lo que puede hacer el agente (buscar con ciertas restricciones, reservar) Las acciones se mandan siempre con un Request Prodriamos resolver las busquedas usando una performativa de Query-ref """ global dsgraph global mss_cnt # Variables globales con los parametros de busqueda de actividades # Realmente creo que podrian ser locales... global location global activity global radius global tipo #logger.info('Peticion de informacion recibida') print 'INFO AgentBuscador=> Peticion de informacion recibida\n' # Extraemos el mensaje y creamos un grafo con el message = request.args['content'] print "INFO AgentBuscador => Mensaje extraído\n" # VERBOSE print message print '\n\n' # Grafo en el que volcamos el contenido de la request gm = Graph() gm.parse(data=message) # Damos por supuesto que el sujeto es una peticion de actividad # En general habra que comprobar de que tipo es la peticion y hacer casos, # aunque creo que podemos poner todas las peticiones en un mosmo grafo # con diferentes sujetos (peticiones) # Propiedades del mensaje msgdic = get_message_properties(gm) # VERBOSE #print msgdic #print '\n\n' # Creo la lista de tipos con UN SOLO tipo # Habra que generalizar esto para mas de un tipo (o no) # Si lo hacemos, el planificador me tendra que pasar una list como parametro # VERBOSE #print "Lista append:" #print lista hotel = myns_pet.hotel busqueda = myns_pet.busqueda originCit = gm.value(subject= busqueda, predicate= myns_par.originCity) destinationCit = gm.value(subject= busqueda, predicate= myns_par.destinationCity) originVuelo="PRG" if str(originCit) == "Barcelona": originVuelo="BCN" elif str(originCit) == "Amsterdam": originVuelo="AMS" elif str(originCit) == "London": originVuelo="LON" elif str(originCit) == "Roma": originVuelo="ROM" elif str(originCit) == "Paris": originVuelo="PAR" destinationVuelo="BCN" destinationCountry="Spain" if str(destinationCit) == "Amsterdam": destinationVuelo="AMS" destinationCountry="Holland" elif str(destinationCit) == "London": destinationVuelo="LON" destinationCountry="United Kingdom" elif str(destinationCit) == "Roma": destinationVuelo="ROM" destinationCountry="Italy" elif str(destinationCit) == "Praha": destinationVuelo="PRG" destinationCountry="Czech Republic" elif str(destinationCit) == "Paris": destinationVuelo="PAR" destinationCountry="France" # Buscamos actividades en el metodo de AgentActividades print "INFO AgentBuscador => Looking for activities (in AgentActividades)..." actividadesInt = gm.triples((None, myns_atr.tipo, None)) gactividades = Graph() for s,p, o in actividadesInt: print o gactividades += buscar_actividades(destinationCity=destinationCit, destinationCountry= destinationCountry, types= [o]) print "INFO AgentBuscador => Activities found" #VERBOSE #Imprimimos el grafo de resultados para ver que pinta tiene #Realmente solo queremos devolverlo al planificador # for s, p, o in gactividades: # print 's: ' + s # print 'p: ' + p # print 'o: ' + o # print '\n' print "Buscamos hoteles" departureDat=gm.value(subject= busqueda, predicate= myns_par.departureDate) returnDat=gm.value(subject= busqueda, predicate= myns_par.returnDate) propertyCategor=gm.value(subject= busqueda, predicate= myns_par.propertyCategory) print "INFO AgentBuscador => Looking for hotels (in AgentHotel)..." ghoteles = buscar_hoteles(destinationCity = destinationCit, destinationCountry = destinationCountry, arrivalDate = departureDat, departureDate = returnDat, propertyCategory = propertyCategor) # Buscamos vuelos print "INFO AgentBuscador => Looking for flights (in AgentFlightsGoogle)..." maxPric=gm.value(subject= busqueda, predicate= myns_par.maxPrice) gvuelos = Graph() gvuelos = buscar_vuelos(origin=originVuelo, destination=destinationVuelo, departureDate= departureDat, returnDate=returnDat, maxPrice=maxPric) # Juntamos los tres grafos en una respuesta grespuesta = Graph() grespuesta = gvuelos + ghoteles + gactividades res_obj= agn['Buscador-responde'] # Comprobamos que sea un mensaje FIPA ACL if msgdic is None: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=AgenteBuscador.uri, msgcnt=mss_cnt) print 'INFO AgentBuscador => El mensaje no era un FIPA ACL' else: # Obtenemos la performativa perf = msgdic['performative'] if perf != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje print "INFO AgentBuscador => No es una request FIPA ACL\n" gr = build_message(Graph(), ACL['not-understood'], sender=AgenteBuscador.uri, msgcnt=mss_cnt) else: # Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente # de registro # Averiguamos el tipo de la accion if 'content' in msgdic: content = msgdic['content'] accion = gm.value(subject=content, predicate=RDF.type) # Aqui realizariamos lo que pide la accion # Retornamos un Inform-done con el grafo del resultado de la busqueda (grespuesta) gr = build_message(grespuesta, ACL['inform-done'], sender=AgenteBuscador.uri, msgcnt=mss_cnt, receiver=msgdic['sender'], content=res_obj ) mss_cnt += 1 print 'INFO AgentBuscador => Respondemos a la peticion de busqueda' return gr.serialize(format='xml')
def register(): """ Entry point del agente que recibe los mensajes de registro La respuesta es enviada al retornar la funcion, no hay necesidad de enviar el mensaje explicitamente Asumimos una version simplificada del protocolo FIPA-request en la que no enviamos el mesaje Agree cuando vamos a responder :return: """ def process_register(): # Si la hay extraemos el nombre del agente (FOAF.Name), el URI del agente # su direccion y su tipo logger.info('Peticion de registro') agn_add = gm.value(subject=content, predicate=DSO.Address) agn_name = gm.value(subject=content, predicate=FOAF.Name) agn_uri = gm.value(subject=content, predicate=DSO.Uri) agn_type = gm.value(subject=content, predicate=DSO.AgentType) # Añadimos la informacion en el grafo de registro vinculandola a la URI # del agente y registrandola como tipo FOAF.Agent dsgraph.add((agn_uri, RDF.type, FOAF.Agent)) dsgraph.add((agn_uri, FOAF.name, agn_name)) dsgraph.add((agn_uri, DSO.Address, agn_add)) dsgraph.add((agn_uri, DSO.AgentType, agn_type)) # Generamos un mensaje de respuesta return build_message(Graph(), ACL.confirm, sender=DirectoryAgent.uri, receiver=agn_uri, msgcnt=mss_cnt) def process_search(): # Asumimos que hay una accion de busqueda que puede tener # diferentes parametros en funcion de si se busca un tipo de agente # o un agente concreto por URI o nombre # Podriamos resolver esto tambien con un query-ref y enviar un objeto de # registro con variables y constantes # Solo consideramos cuando Search indica el tipo de agente # Buscamos una coincidencia exacta # Retornamos el primero de la lista de posibilidades logger.info('Peticion de busqueda') agn_type = gm.value(subject=content, predicate=DSO.AgentType) rsearch = dsgraph.triples((None, DSO.AgentType, agn_type)) if rsearch is not None: agn_uri = rsearch.next()[0] agn_add = dsgraph.value(subject=agn_uri, predicate=DSO.Address) gr = Graph() gr.bind('dso', DSO) rsp_obj = agn['Directory-response'] gr.add((rsp_obj, DSO.Address, agn_add)) gr.add((rsp_obj, DSO.Uri, agn_uri)) return build_message(gr, ACL.inform, sender=DirectoryAgent.uri, msgcnt=mss_cnt, receiver=agn_uri, content=rsp_obj) else: # Si no encontramos nada retornamos un inform sin contenido return build_message(Graph(), ACL.inform, sender=DirectoryAgent.uri, msgcnt=mss_cnt) global dsgraph global mss_cnt # Extraemos el mensaje y creamos un grafo con él message = request.args['content'] gm = Graph() gm.parse(data=message) msgdic = get_message_properties(gm) # Comprobamos que sea un mensaje FIPA ACL if not msgdic: # Si no es, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=DirectoryAgent.uri, msgcnt=mss_cnt) else: # Obtenemos la performativa if msgdic['performative'] != ACL.request: # Si no es un request, respondemos que no hemos entendido el mensaje gr = build_message(Graph(), ACL['not-understood'], sender=DirectoryAgent.uri, msgcnt=mss_cnt) else: # Extraemos el objeto del contenido que ha de ser una accion de la ontologia # de registro content = msgdic['content'] # Averiguamos el tipo de la accion accion = gm.value(subject=content, predicate=RDF.type) # Accion de registro if accion == DSO.Register: gr = process_register() # Accion de busqueda elif accion == DSO.Search: gr = process_search() # No habia ninguna accion en el mensaje else: gr = build_message(Graph(), ACL['not-understood'], sender=DirectoryAgent.uri, msgcnt=mss_cnt) mss_cnt += 1 return gr.serialize(format='xml')