示例#1
0
 def test_find_and_handle_stale_conversations(self):
     conversation = StubConversation(12344)
     conversation.retries_made = 6
     table = ConversationTable()
     table.add_conversation("stub_host", "stub_port", conversation)
     performer = Performer(self.sock, table, 10, 6)
     performer.find_and_handle_stale_conversations()
     self.assertEqual(len(table), 0)
示例#2
0
 def test_handle_stale_conversation_retry(self):
     conversation = StubConversation(12344)
     conversation.retries_made = 0
     table = ConversationTable()
     performer = Performer(self.sock, table, 10, 6)
     performer._handle_stale_conversation(conversation)
     self.assertEqual(self.sock.sent_data, "stub_packet_data")
     self.assertEqual(self.sock.sent_addr, ("stub_host", "stub_port"))
示例#3
0
 def test_find_and_handle_stale_conversations(self):
     conversation = StubConversation(12344)
     conversation.retries_made = 6
     table = ConversationTable()
     table.add_conversation("stub_host", "stub_port", conversation)
     performer = Performer(self.sock, table, 10, 6)
     performer.find_and_handle_stale_conversations()
     self.assertEqual(len(table), 0)
示例#4
0
 def test_handle_stale_conversation_retry(self):
     conversation = StubConversation(12344)
     conversation.retries_made = 0
     table = ConversationTable()
     performer = Performer(self.sock, table, 10, 6)
     performer._handle_stale_conversation(conversation)
     self.assertEqual(self.sock.sent_data, "stub_packet_data")
     self.assertEqual(self.sock.sent_addr, ("stub_host", "stub_port"))
示例#5
0
 def test_handle_stale_conversation_giveup(self):
     conversation = StubConversation(12344)
     conversation.retries_made = 6
     table = ConversationTable()
     table.add_conversation("stub_host", "stub_port", conversation)
     performer = Performer(self.sock, table, 10, 6)
     performer._handle_stale_conversation(conversation)
     self.assertEqual(self.sock.sent_data,
         '\x00\x05\x00\x00Conversation Timed Out\x00')
     self.assertEqual(self.sock.sent_addr, ("stub_host", "stub_port"))
     self.assertIsNone(table.get_conversation("stub_host", "stub_port"), None)
示例#6
0
 def test_handle_stale_conversation_giveup(self):
     conversation = StubConversation(12344)
     conversation.retries_made = 6
     table = ConversationTable()
     table.add_conversation("stub_host", "stub_port", conversation)
     performer = Performer(self.sock, table, 10, 6)
     performer._handle_stale_conversation(conversation)
     self.assertEqual(self.sock.sent_data,
                      '\x00\x05\x00\x00Conversation Timed Out\x00')
     self.assertEqual(self.sock.sent_addr, ("stub_host", "stub_port"))
     self.assertIsNone(table.get_conversation("stub_host", "stub_port"),
                       None)
示例#7
0
    def test_get_stale_conversations(self):
        table = ConversationTable()
        conversation_one = StubConversation(12344)
        conversation_two = StubConversation(12345)
        conversation_three = StubConversation(12346)
        table.conversation_table = {
            ("10.26.0.1", "3942"): conversation_one,
            ("10.26.0.2", "3942"): conversation_two,
            ("10.26.0.3", "3942"): conversation_three
        }

        performer = Performer(self.sock, table, 10, 6)

        # Either order of returned results is fine
        self.assertTrue(performer._get_stale_conversations(5, 12350)
            == [conversation_one, conversation_two]
            or performer.get_stale_conversations(5, 12350)
            == [conversation_two, conversation_one],
            "stale conversations found don't match")
示例#8
0
 def perform_sign(self):
     settings_dx, settings_sx = self.get_settings()
     for i in range(0, 4):
         Performer(
             self.robot,
             [[settings_dx[i][0]], [settings_sx[i][0]]],
             [settings_dx[i][1], settings_sx[i][1]],
             [settings_dx[i][2], settings_sx[i][2]],
         )
     utils.get_rest_position(self.robot)
示例#9
0
 def __init__(self):
     self.host = config.HOST
     self.port = config.PORT
     self.response_router = ResponseRouter()
     self.conversation_table = ConversationTable()
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     self.reactor = Reactor(self.sock, self.response_router,
                            self.conversation_table)
     self.performer = Performer(self.sock, self.conversation_table,
                                config.RESEND_TIMEOUT,
                                config.RETRIES_BEFORE_GIVEUP)
示例#10
0
    def test_get_stale_conversations(self):
        table = ConversationTable()
        conversation_one = StubConversation(12344)
        conversation_two = StubConversation(12345)
        conversation_three = StubConversation(12346)
        table.conversation_table = {
            ("10.26.0.1", "3942"): conversation_one,
            ("10.26.0.2", "3942"): conversation_two,
            ("10.26.0.3", "3942"): conversation_three
        }

        performer = Performer(self.sock, table, 10, 6)

        # Either order of returned results is fine
        self.assertTrue(
            performer._get_stale_conversations(
                5, 12350) == [conversation_one, conversation_two]
            or performer.get_stale_conversations(
                5, 12350) == [conversation_two, conversation_one],
            "stale conversations found don't match")
示例#11
0
    def test_sweep_completed_conversations(self):
        conversation_one = StubConversation(12344)
        conversation_one.state = tftp_conversation.COMPLETED

        conversation_two = StubConversation(12345)
        conversation_two.state = tftp_conversation.READING

        conversation_three = StubConversation(12346)
        conversation_three.state = tftp_conversation.COMPLETED

        table = ConversationTable()
        table.conversation_table = {
                ("10.26.0.1", "3942"): conversation_one,
                ("10.26.0.2", "3942"): conversation_two,
                ("10.26.0.3", "3942"): conversation_three
        }

        performer = Performer(self.sock, table, 10, 6)
        performer.sweep_completed_conversations()
        self.assertEqual(table.conversation_table,
            {("10.26.0.2", "3942"): conversation_two, })
示例#12
0
    def test_sweep_completed_conversations(self):
        conversation_one = StubConversation(12344)
        conversation_one.state = tftp_conversation.COMPLETED

        conversation_two = StubConversation(12345)
        conversation_two.state = tftp_conversation.READING

        conversation_three = StubConversation(12346)
        conversation_three.state = tftp_conversation.COMPLETED

        table = ConversationTable()
        table.conversation_table = {
            ("10.26.0.1", "3942"): conversation_one,
            ("10.26.0.2", "3942"): conversation_two,
            ("10.26.0.3", "3942"): conversation_three
        }

        performer = Performer(self.sock, table, 10, 6)
        performer.sweep_completed_conversations()
        self.assertEqual(table.conversation_table, {
            ("10.26.0.2", "3942"): conversation_two,
        })
示例#13
0
 def __init__(self, event_data):
     self.listing_count = event_data['stats']['listing_count']
     self.average_price = event_data['stats']['average_price']
     self.lowest_price_good_deals = event_data['stats'][
         'lowest_price_good_deals']
     self.lowest_price = event_data['stats']['lowest_price']
     self.highest_price = event_data['stats']['highest_price']
     self.title = event_data['title']
     self.url = event_data['url']
     self.datetime_local = event_data['datetime_local']
     self.announce_date = event_data['announce_date']
     self.visible_until_utc = event_data['visible_until_utc']
     self.time_tbd = event_data['time_tbd']
     self.date_tbd = event_data['date_tbd']
     self.performers = [
         Performer(performer) for performer in event_data['performers']
     ]
     self.venue = Venue(event_data['venue'])
     self.short_title = event_data['short_title']
     self.score = event_data['score']
     self.taxonomies = event_data['taxonomies']
     self.type = event_data['type']
示例#14
0
import argparse
from environments import environments
from performer import Performer

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--environment',
        default='RLBench',
        help='Environment to use for training [default = RLBench]')
    parser.add_argument(
        '--load_model',
        default='./model.model',
        help='Path to load the model [default = [./model.model]')
    parser.add_argument(
        '--n_tests',
        default=10,
        type=int,
        help='How many times to run the simulation [default = 10]')
    args = parser.parse_args()

    SIMULATOR, NETWORK = environments[args.environment]
    model = NETWORK()
    model.load(args.load_model)

    performer = Performer(0, model, SIMULATOR)

    performer.perform(args)
示例#15
0
from naoqi import ALProxy
from configuration import nao_ip, nao_port, music_path, modules_list
from search import IterativeDeepening
import numpy as np
import time
from performer import Performer

mpm = 60/(136/4)

mandatory_position = [14, 17, 15, 18, 11, 13, 12, 1]
mandatory_times = [0, 14.12, 14.12, 28.24, 28.24, 28.24, 26.47, 15.88]

pool_times = np.loadtxt('times.txt')
search_alg = IterativeDeepening(pool_times, max_error=0.01, max_depth=5)

solution = search_alg.find_complete_path(mandatory_position, mandatory_times, mpm)
print(solution)

positions = [modules_list[i] for i in solution]

performer = Performer(nao_ip, nao_port, positions[0])

t1 = time.time()
performer.perform(positions[1:], music_path)
print("Tempo effettivo: ", time.time() - t1)