def on_propose(self, msg_id: int, dialogue_id: int, origin: str, target: int, proposals: PROPOSE_TYPES): for i,p in enumerate(proposals): self.received_proposals.append({"agent" : origin, "proposal":p.values}) newPrice = self.received_proposals[0]['proposal']['price'] newOffer = newPrice + self.interval self.prevPrice = newOffer if self.Auction == False: if self.received_proposals[0]['proposal']['auction']: print('[{0}] Accepting Auction with maxPrice: {1}, at interval: {2}'.format(self.public_key, self.maxPrice, self.interval)) self.send_accept(msg_id, dialogue_id, self.received_proposals[0]['agent'], msg_id+1) self.received_proposals.clear() self.Auction = True else: if self.received_proposals[0]['proposal']['auction'] == False: if newPrice <= self.maxPrice: print('Accepting Offer of Price: {}'.format(newPrice)) self.send_accept(msg_id, dialogue_id, self.received_proposals[0]['agent'], msg_id+1) self.api.sync(self.api.tokens.transfer(self.account, Address(origin) , self.prevPrice - self.interval, 20)) print('Final Balance:', self.api.tokens.balance(self.account)) else: print('Cannot Afford') self.send_decline(msg_id,dialogue_id,self.received_proposals['agent'],msg_id + 1) if newOffer <= self.maxPrice: print('{} : Sending proposal of: {}'.format(self.public_key,newOffer)) proposal = Description({"price" : newOffer}) self.send_propose(msg_id+1, dialogue_id, origin, target+1, [proposal]) self.received_proposals.clear() else: print('{} : Sending proposal of: {}'.format(self.public_key,self.maxPrice)) proposal = Description({"price" : self.maxPrice}) self.send_propose(msg_id+1, dialogue_id, origin, target+1, [proposal]) self.received_proposals.clear()
def test_on_search_result_agents(self, local): """ Test that an agent can do a search for agents. """ with setup_test_agents(3, local, prefix="search_agents") as agents: for a in agents: a.connect() agent_0, agent_1, agent_2 = agents foo_attr = AttributeSchema("foo", int, False, "A foo attribute.") bar_attr = AttributeSchema("bar", str, False, "A bar attribute.") dummy_datamodel = DataModel("dummy_datamodel", [foo_attr, bar_attr]) agent_1.register_agent( 0, Description({ "foo": 15, "bar": "BAR" }, dummy_datamodel)) agent_2.register_agent( 0, Description({ "foo": 5, "bar": "ABC" }, dummy_datamodel)) agent_0.search_agents( 0, Query([Constraint("foo", Eq(0))], dummy_datamodel)) agent_0.search_agents( 0, Query([ Constraint("foo", Gt(10)), Constraint("bar", Gt("B")), ], dummy_datamodel)) agent_0.search_agents( 0, Query([ Constraint("bar", Gt("A")), ], dummy_datamodel)) asyncio.ensure_future(agent_0.async_run()) asyncio.get_event_loop().run_until_complete( asyncio.sleep(_ASYNCIO_DELAY)) agent_1.unregister_agent(0) agent_2.unregister_agent(0) expected_message_01 = (0, []) expected_message_02 = (0, [agent_1.public_key]) expected_message_03 = (0, [agent_1.public_key, agent_2.public_key]) assert 3 == len(agent_0.received_msg) assert expected_message_01 == agent_0.received_msg[0] assert expected_message_02 == agent_0.received_msg[1] assert expected_message_03 == agent_0.received_msg[2]
def on_propose(self, msg_id: int, dialogue_id: int, origin: str, target: int, proposals: PROPOSE_TYPES): """When we receive a Propose message, check if we can afford the data. If so we accept, else we decline the proposal.""" print("[{0}]: Received propose from agent {1}".format(self.public_key, origin)) for i,p in enumerate(proposals): self.received_proposals.append({"agent" : origin, "proposal":p.values}) received_cfp = len(self.received_proposals) + self.received_declines global currentPrice self.received_proposals.sort(key = lambda i: (i['proposal']['id']), reverse = True) # once everyone has responded, let's accept them. print("I am here") if len( self.received_proposals) >= 1 : proposed = str(self.received_proposals[0]['proposal']) price = int(self.received_proposals[0]['proposal']['price']) offer = int(self.received_proposals[0]['proposal']['offer']) previous = int(self.received_proposals[0]['proposal']['previous']) proposalID = self.received_proposals[0]['proposal']['id'] print('----->PRICE:', price) print('----->OFFER:', offer) print('----->PREVIOUS:', previous) print('----->ID:', proposalID) if price <= highest_price: print('Accept the offer!') #check if we can afford the data. if api.tokens.balance(client_agentID) > price : #if we can, transfer tokens from the client account to the proposal address. api.sync(api.tokens.transfer(client_agentID, Address(self.received_proposals[0]['agent']) , price, 20)) self.send_accept(msg_id,dialogue_id,self.received_proposals[0]['agent'],msg_id + 1) print ("Accept") else : print("Not enough tokens!") #cannot afford! Decline the proposal. self.send_decline(msg_id,dialogue_id,self.received_proposals[0]['agent'],msg_id + 1) self.stop() elif price == previous: print('They are sticking with offer, better offer higher...') proposal = Description({"price" : highest_price, "previous": price, "offer": offer, "id": proposalID+1}) print("[{0}]: Sending propose at price: {1}".format(self.public_key, highest_price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal]) else: print('Too Expensive, want lower!') self.reduceOffer(price) proposal = Description({"price" : currentPrice, "previous": price, "offer": offer, "id": proposalID+1}) print("[{0}]: Sending propose at price: {1}".format(self.public_key, currentPrice)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal]) else : print("They don't have data") self.stop()
def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) #data = self.get_latest(0) if self.preferences["currentCapacity"] < self.preferences['maxAllowed']: proposal = Description({ "data": True, "driverVect": json.dumps(self.preferences) }) else: proposal = Description({"data": False}) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal])
def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) data = json.loads(query.decode("UTF-8")) print("GOT DATA: ", data) # prepare the proposal with a given price. price = 50 proposal = Description({"price": price}) print("[{}]: Sending propose at price: {}".format( self.public_key, price)) print("********", proposal.to_pb()) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal])
def test_group_dialogue_one_client_n_servers(self): with NetworkOEFNode(): client_proxy = OEFNetworkProxy("client", oef_addr="127.0.0.1", port=3333) client = ClientAgentGroupDialogueTest(client_proxy) client.connect() N = 10 server_proxies = [ OEFNetworkProxy("server_{:02d}".format(i), oef_addr="127.0.0.1", port=3333) for i in range(N) ] server_data_model = DataModel("server", [AttributeSchema("foo", bool, True)]) servers = [ ServerAgentTest(server_proxy, price=random.randint(10, 100)) for server_proxy in server_proxies ] for server in servers: server.connect() server.register_service( 0, Description({"foo": True}, server_data_model)) best_server = ServerAgentTest(OEFNetworkProxy("best_server", oef_addr="127.0.0.1", port=3333), price=5) best_server.connect() best_server.register_service( 0, Description({"foo": True}, server_data_model)) servers.append(best_server) asyncio.get_event_loop().run_until_complete( asyncio.sleep(_ASYNCIO_DELAY)) query = Query([Constraint("foo", Eq(True))], server_data_model) client.search_services(0, query) asyncio.get_event_loop().run_until_complete( asyncio.gather(client.async_run(), *[server.async_run() for server in servers])) assert "best_server" == client.group.best_agent assert 5 == client.group.best_price
def on_propose(self, msg_id: int, dialogue_id: int, origin: str, target: int, proposals: PROPOSE_TYPES): """When we receive a Propose message, check if we can afford the data. If so we accept, else we decline the proposal.""" print("[{0}]: Received propose from agent {1}".format(self.public_key, origin)) for i,p in enumerate(proposals): self.received_proposals.append({"agent" : origin, "proposal":p.values}) received_cfp = len(self.received_proposals) + self.received_declines self.proposalsTot = self.proposalsTot + 1 print('prevOffer:', self.prevOffer) print("I am here") if len( self.received_proposals) >= 1 : proposed = str(self.received_proposals[self.proposalsTot-1]['proposal']) price = int(self.received_proposals[self.proposalsTot-1]['proposal']['price']) print('----->PRICE:', price) if price >= self.lowest_price: print('Good offer! Return offer and wait for accept...') proposal = Description({"price" : price}) print("[{0}]: Sending propose at price: {1}".format(self.public_key, price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal]) elif price == self.prevOffer: print('Not going high enough. Ending dialogue') self.prevPrice = self.wanted_price self.prevOffer = 0 self.send_decline(msg_id,dialogue_id,self.received_proposals[self.proposalsTot-1]['agent'],msg_id + 1) return else: print('Too Low!') self.prevOffer = price price = ((price + self.prevPrice)/2) if price >= self.lowest_price: print('Ok, meet in the middle') self.prevPrice = price proposal = Description({"price" : price}) print("[{0}]: Sending propose at price: {1}".format(self.public_key, price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal]) else: print('Not Budging!') price = self.prevPrice proposal = Description({"price" : price}) print("[{0}]: Sending propose at price: {1}".format(self.public_key, price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal]) else: print("They don't have data") self.stop()
def test_unregister_service(self, local): """ Test that the unregistration of services works correctly. """ with setup_test_agents(2, local, prefix="unregister_service") as agents: for a in agents: a.connect() agent_0, agent_1 = agents dummy_datamodel = DataModel("dummy_datamodel", [AttributeSchema("foo", int, False)]) dummy_service_description = Description({}, dummy_datamodel) agent_1.register_service(0, dummy_service_description) agent_1.unregister_service(0, dummy_service_description) agent_0.search_services( 0, Query([Constraint("foo", Eq(0))], dummy_datamodel)) asyncio.ensure_future(agent_0.async_run()) asyncio.get_event_loop().run_until_complete( asyncio.sleep(_ASYNCIO_DELAY)) assert 1 == len(agent_0.received_msg) assert (0, []) == agent_0.received_msg[0]
def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) price = self.price timeArr = [] for key in self.scheduler.keys(): timeArr.append(self.scheduler[key]) # prepare the proposal with a given price. proposal = Description({ "price_per_energy_percent": price, "digest": str(self._contract), "longitude": self.longitude, "latitude": self.latitude, "scheduler": json.dumps(timeArr), "rate": self.rate, "max_count": self.max_count, "charger_address": str(Address(self.chargers[0])) }) print("[{}]: Sending propose at price: {}".format( self.public_key, price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal])
def test_serialization(self, description): """Test that serialization and deserialization of Description objects work correctly.""" actual_description = description actual_description_pb = actual_description.to_pb( ) # type: query_pb2.Query.DataModel expected_description = Description.from_pb(actual_description_pb) assert actual_description == expected_description
def __init__(self, public_key, oef_addr, oef_port, data_model_json, service_description_json, data_to_send_json, price): OEFAgent.__init__(self, public_key, oef_addr, oef_port) self.data_model = modlify(data_model_json) self.service = Description(service_description_json, self.data_model) self.data = data_to_send_json self.price = price
def test2(self): price = 50 proposed_price = Description({"price": price}) proposals = [proposed_price] data = { "msg_id": 102, "agent_uri": "wibble1", "send_message": { "dialogue_id": 101, "destination": "wibble2", "target_uri": "uri1", "source_uri": "uri2", "fipa": { "target": 102, "propose": { ("content" if type(proposals) == bytes else None): proposals, ("proposals" if type(proposals) != bytes else None): { "objects": proposals, }, } } } } oefagent = OefMessageHandler() senddata = oefagent.make_message(bytes=None, json=None, message_class=agent_pb2.Envelope, data=data, pb=None)
def test1(self): weather_service_description = Description( { "wind_speed": False, "temperature": True, "air_pressure": True, "humidity": True, }, WEATHER_DATA_MODEL) # data = { # "msg_id": 1, # "register_service": { # "description": weather_service_description.to_dict() # }, # } # pb = agent_pb2.Envelope() # self.tryit(pb, data) data = { "msg_id": 1, "register_service": { "description": weather_service_description }, } pb = agent_pb2.Envelope() self.tryit(pb, data)
class TransportAgent(OEFAgent): """Class that implements the behaviour of the scooter agent.""" scooter_description = Description( { "price_per_km": True, }, JOURNEY_MODEL ) def __init__(self, data, *args, **kwargs): super(TransportAgent, self).__init__(*args, **kwargs) self.data = data self._entity = Entity() self._address = Address(self._entity) # with open("./full_contract.etch", "r") as fb: # self._source = fb.read() # self.prepare_contract() def prepare_contract(self): # Setting API up self._api = LedgerApi('185.91.52.11', 10002) # Need funds to deploy contract self._api.sync(self._api.tokens.wealth(self._entity, 5000000)) # Create contract self._contract = SmartContract(self._source) # Deploy contract self._api.sync(self._api.contracts.create(self._entity, self._contract, 2456766)) def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) price = 1 # prepare the proposal with a given price. proposal = Description({"price_per_km": price}) print("[{}]: Sending propose at price: {}".format(self.public_key, price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal]) def on_accept(self, msg_id: int, dialogue_id: int, origin: str, target: int): """Once we received an Accept, send the requested data.""" print("[{0}]: Received accept from {1}." .format(self.public_key, origin)) # Preparing contract # PLACE HOLDER TO PREPARE AND SIGN TRANSACTION contract = {"contract": "data"} # Sending contract encoded_data = json.dumps(contract).encode("utf-8") print("[{0}]: Sending contract to {1}".format(self.public_key, origin)) self.data['status'] = 'RIDES' self.send_message(0, dialogue_id, origin, encoded_data)
def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) proposal = Description({"price": self.price}) print("[{}]: Sending propose at price: {}".format( self.public_key, self.price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal])
def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) # prepare the proposal with a given price. proposal = Description({"price": self.price}) print("[{}]: Sending propose at price: {}".format(self.public_key, self.price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal])
def register(self): """ Register on the OEF as a TAC controller agent. :return: None. """ desc = Description({"version": 1}, data_model=self.CONTROLLER_DATAMODEL) logger.debug("[{}]: Registering with {} data model".format(self.name, desc.data_model.name)) self.register_service(0, desc)
def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) #data = self.get_latest(0) proposal = Description({"data": True}) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal])
def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) #format the price for number extraction on other agent proposal = Description({"price" : self.wanted_price}) print("[{0}]: Sending propose at price: {1}".format(self.public_key, wanted_price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal]) startBalance = api.tokens.balance(server_agentID)
async def loop(self, agent: AgentInterface) -> None: # noqa: C901 """ Event loop to wait for messages and to dispatch the arrived messages to the proper handler. :param agent: the implementation of the message handlers specified in AgentInterface. :return: ``None`` """ while True: try: data = await self._receive() except asyncio.CancelledError: logger.debug("Proxy {}: loop cancelled".format(self.public_key)) break msg = agent_pb2.Server.AgentMessage() msg.ParseFromString(data) case = msg.WhichOneof("payload") logger.debug("loop {0}".format(case)) if case == "agents": agent.on_search_result(msg.answer_id, msg.agents.agents) elif case == "oef_error": agent.on_oef_error(msg.answer_id, OEFErrorOperation(msg.oef_error.operation)) elif case == "dialogue_error": agent.on_dialogue_error(msg.answer_id, msg.dialogue_error.dialogue_id, msg.dialogue_error.origin) elif case == "content": content_case = msg.content.WhichOneof("payload") logger.debug("msg content {0}".format(content_case)) if content_case == "content": agent.on_message(msg.answer_id, msg.content.dialogue_id, msg.content.origin, msg.content.content) elif content_case == "fipa": fipa = msg.content.fipa fipa_case = fipa.WhichOneof("msg") if fipa_case == "cfp": cfp_case = fipa.cfp.WhichOneof("payload") if cfp_case == "nothing": query = None elif cfp_case == "content": query = fipa.cfp.content elif cfp_case == "query": query = Query.from_pb(fipa.cfp.query) else: raise Exception("Query type not valid.") agent.on_cfp(msg.answer_id, msg.content.dialogue_id, msg.content.origin, fipa.target, query) elif fipa_case == "propose": propose_case = fipa.propose.WhichOneof("payload") if propose_case == "content": proposals = fipa.propose.content else: proposals = [Description.from_pb(propose) for propose in fipa.propose.proposals.objects] agent.on_propose(msg.answer_id, msg.content.dialogue_id, msg.content.origin, fipa.target, proposals) elif fipa_case == "accept": agent.on_accept(msg.answer_id, msg.content.dialogue_id, msg.content.origin, fipa.target) elif fipa_case == "decline": agent.on_decline(msg.answer_id, msg.content.dialogue_id, msg.content.origin, fipa.target) else: logger.warning("Not implemented yet: fipa {0}".format(fipa_case))
def check_inconsistency_checker(schema: List[AttributeSchema], values: Dict[str, ATTRIBUTE_TYPES], exception_string): """ Used to check that that AttributeInconsistencyException is raised with a certain string when the two inconsistent schema and values are used to build a Description """ data_model = DataModel("foo", schema, "") with pytest.raises(AttributeInconsistencyException, match=exception_string): _ = Description(values, data_model)
def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Propose the and start the auction if not already in motion.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) price = self.startPrice proposal = Description({"auction" : True, "price" : price}) print("[{0}]: Sending propose at price: {1}".format(self.public_key, price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal]) if self.auction == False: x = threading.Timer(5, self.startAuction) x.start() self.auction = True
def descriptions(draw, from_data_model=False): if from_data_model: data_model = draw(data_models()) attributes = data_model.attribute_schemas else: data_model = None attributes = draw(lists(attributes_schema(), max_size=3)) attributes_values = draw(schema_instances(attributes)) d = Description(attributes_values, data_model) return d
def load_service(self, metadata, load_path): dataset_info = metadata['base'] attributes = description = {} for item in dataset_info['tags']: attributes[item] = description[item] = 'Tagged: ' + item attribute_list = [] for key, value in attributes.items(): attribute_list.append(AttributeSchema(key, str, False, value)) data_model = DataModel(dataset_info['name'], attribute_list, dataset_info['description']) service = Description(description, data_model) data = Utils.load_json(load_path) return service, data
class WeatherStation(OEFAgent): """Class that implements the behaviour of the weather station.""" weather_service_description = Description( { "wind_speed": False, "temperature": True, "air_pressure": True, "humidity": True, }, WEATHER_DATA_MODEL) def on_connection_terminated(self, url=None): print("Connection ended.") def on_cfp(self, msg_id: int, dialogue_id: int, origin: str = None, target: int = None, query: CFP_TYPES = None): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) info = json.loads(query) print(info["where_i_am"]) # prepare the proposal with a given price. price = 50 proposed_price = Description({"price": price}) proposals = [proposed_price] print("[{}]: Sending propose at price: {}".format( self.public_key, price)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, proposals) def on_accept(self, msg_id: int, dialogue_id: int, origin: str = None, target: int = None): """Once we received an Accept, send the requested data.""" print("[{0}]: Received accept from {1}.".format( self.public_key, origin)) # send the measurements to the client. for the sake of simplicity, they are hard-coded. data = {"temperature": 15.0, "humidity": 0.7, "air_pressure": 1019.0} encoded_data = json.dumps(data).encode("utf-8") print("[{0}]: Sending data to {1}: {2}".format(self.public_key, origin, pprint.pformat(data))) self.send_message(0, dialogue_id, origin, encoded_data)
def test3(self): proposal = Description({ "lat": float(8.9), "lon": float(8.11), "price": float(123.45), "friendly_name": "i am legend", "last_detection_time": float(1000.88888), "max_spaces": 99, }) proposals = [proposal] data = { "msg_id": 102, "agent_uri": "wibble1", "send_message": { "dialogue_id": 101, "destination": "wibble2", "target_uri": "I_AM_URL1", "source_uri": "I_AM_URL2", "fipa": { "target": 102, "propose": { ("content" if type(proposals) == bytes else None): proposals, ("proposals" if type(proposals) != bytes else None): { "objects": proposals, }, } } } } oefagent = OefMessageHandler() senddata = oefagent.make_message(bytes=None, json=None, message_class=agent_pb2.Envelope, data=data, pb=None) #print(senddata) assert b"I_AM_URL1" in senddata assert b"I_AM_URL2" in senddata inbound = agent_pb2.Envelope() inbound.ParseFromString(senddata) contents = protoToDict(inbound) #print(contents) oink = contents #print(oink['send_message']['fipa']['propose']['proposals']['objects']) assert len(oink) > 1
def on_cfp(self, msg_id: int, dialogue_id: int, origin: str, target: int, query: CFP_TYPES): """Send a simple Propose to the sender of the CFP.""" print("[{0}]: Received CFP from {1}".format(self.public_key, origin)) # prepare the proposal with a given price. proposal = Description({ "price_kilowatt_hour": self.price_kwh, "charger_location": self.location, 'charger_bonus': self.bonus }) print("[{}]: Sending propose at price: {} location {},{}".format( self.public_key, self.price_kwh, self.location.latitude, self.location.longitude)) self.send_propose(msg_id + 1, dialogue_id, origin, target + 1, [proposal])
def __init__(self, data, *args, **kwargs): super(TransportAgent, self).__init__(*args, **kwargs) self._entity = Entity() self._address = Address(self._entity) self.data = { 'price_per_km': data['price_per_km'], 'state': "WAIT", 'location_latitude': data['location'].latitude, 'location_longitude': data['location'].longitude } self.transport_description = Description(self.data, TRANSPORT_DATAMODEL()) self.distance_allowed_area = 5 self.velocity = 0.0005
def makeAgent(preferences): idd = str(base58.b58encode("Driver{}".format(preferences["id"]))).replace( "'", str(random.randint(0, 9999999999999999999999999999))) print(idd) OEF_Address = os.environ.get('OEF_ADDRESS') OEF_Port = os.environ.get('OEF_PORT') print("HERE!", OEF_Address, OEF_Port) #) server_agent = Demo_Agent( idd, oef_addr=OEF_Address, oef_port=OEF_Port, preferences=preferences) # oef.economicagents.com server_agent.scheme['timezone'] = 2 server_agent.scheme['id'] = str(uuid.uuid4()) server_agent.connect() # register a service on the OEF server_agent.description = Description(server_agent.scheme, TIME_AGENT()) server_agent.register_service(0, server_agent.description) # server_agent.run() return server_agent, idd
def get_goods_quantities_description(good_pbks: List[str], good_quantities: List[int], is_supply: bool) -> Description: """ Get the TAC description for supply or demand. That is, a description with the following structure: >>> description = { ... "tac_good_0": 1, ... "tac_good_1": 0, ... #... ... ... } >>> where the keys indicate the good_pbk and the values the quantity. >>> desc = get_goods_quantities_description(['tac_good_0', 'tac_good_1', 'tac_good_2', 'tac_good_3'], [0, 0, 1, 2], True) >>> desc.data_model.name == TAC_SUPPLY_DATAMODEL_NAME True >>> desc.values == { ... "tac_good_0": 0, ... "tac_good_1": 0, ... "tac_good_2": 1, ... "tac_good_3": 2} ... True :param good_pbks: the public keys of the goods. :param good_quantities: the quantities per good. :param is_supply: True if the description is indicating supply, False if it's indicating demand. :return: the description to advertise on the Service Directory. """ data_model = build_datamodel(good_pbks, is_supply=is_supply) desc = Description( { good_pbk: quantity for good_pbk, quantity in zip(good_pbks, good_quantities) }, data_model=data_model) return desc