def create_result_set(self, reading_system, testsuite, user):
        from result import Result
        from score import Score, AccessibilityScore
        from testsuite_app import helper_functions
        last_updated = helper_functions.generate_timestamp()
        result_set = ResultSet(reading_system = reading_system, testsuite=testsuite, last_updated = last_updated, user = user)
        result_set.save()   
        print "Creating result set"
        # create empty results for each test
        tests = testsuite.get_tests()
        for test in tests:
            result = Result(result_set = result_set, test = test)
            result.save()

        # create empty scores for each category
        categories = testsuite.get_categories()
        for cat in categories:
            if testsuite.testsuite_type == common.TESTSUITE_TYPE_DEFAULT:
                score = Score(category = cat, result_set = result_set)
                score.save()
            else:
                score = AccessibilityScore(category = cat, result_set = result_set)
                score.save()

        if testsuite.testsuite_type == common.TESTSUITE_TYPE_DEFAULT:
            overall_score = Score(category = None, result_set = result_set)
            overall_score.save()
        else:
            overall_score = AccessibilityScore(category = None, result_set = result_set)
            overall_score.save()

        result_set.visibility = reading_system.visibility

        return result_set

 def test_sources_are_stored(self):
     r = Result()
     r.add("foo", Source("handle", "what they twote about foo", "twitter.com/linktotweet"))
     s = r.get_source_list("foo")
     self.assertEqual(s[0].handle, "handle")
     self.assertEqual(s[0].text, "what they twote about foo")
     self.assertEqual(s[0].link, "twitter.com/linktotweet")

    def __init__(self, data, model, learning_rate=0.01, l1_rate=0.0, l2_rate=0.0):
        assert isinstance(data, Data)
        assert isinstance(model, Model)
        self.data = data
        self.model = model
        self.result = Result()
        self.params_result = Result(os.path.join(self.result.dir, "params"))

        weights = [p for p in self.model.params if "weight" in p.name or "filter" in p.name]
        l1 = np.sum([abs(w).sum() for w in weights])
        l2 = np.sum([(w ** 2).sum() for w in weights])

        self._cost = function(
            inputs=(self.model.input_symbol, self.model.answer_symbol),
            outputs=self.model.cost(True) + l1_rate * l1 + l2_rate * l2,
            updates=self._update(learning_rate),
        )

        self._train_error = function(
            inputs=(self.model.input_symbol, self.model.answer_symbol), outputs=self.model.error(True), updates=[]
        )

        self._test_error = function(
            inputs=(self.model.input_symbol, self.model.answer_symbol), outputs=self.model.error(False), updates=[]
        )

    def parseScript(self, scriptURL):
        result = Result(TBTAFParsingScriptStatus.SUCCESS, "Success")
        file = None
        try:
            file = self._openFile(scriptURL)
            self._parseFile(file, result)

            if (result.status==TBTAFParsingScriptStatus.ERROR):
                file.close()
                ##return result
            else:
                if (TBTAFInterpreter.OrchestratorReference is None):
                    result.status=TBTAFParsingScriptStatus.ERROR
                    result.message="Orchestrator Reference has not been set."
                    ##return result

                if(result.status==TBTAFParsingScriptStatus.SUCCESS):
                    self.startExecution(TBTAFInterpreter.OrchestratorReference)

            #print result.status
            #print result.message

        except Exception as e:
            #traceback.print_exc(e)
            raise e
        finally:
            if(file is not None):
                file.close()

        return result

    def get_results(self):
        """
        This function reads the file saved by the simulator at the end of the simulation to retrieve results
        :return: Dictionary containing simulation results
        """

        # Retrieve filename
        res = Result()
        results = res.get_results(self.filename)
        return results

 def collate_words(self, meme, sources):
     """Given a list of Sources and a Meme, populate a Result
     object with matching words"""
     regex = self._format_regex(meme)
     result = Result()
     for source in sources:
         match = re.search(regex, source.text, re.IGNORECASE)
         if match:
             result.add(match.groups()[0].lower(), source)
             #assumption: there was exactly one match
     return result

 def run(self):
     while True:
         rid = libimport.GetNextListenResult(self.iid)
         if rid is not None:
             function = libimport.GetNextListenResultFunction(self.iid).decode('ascii')
             inparams = libimport.GetNextListenResultInParameter(self.iid)
             params = libimport.GetNextListenResultParameter(self.iid)
             request = Request(rid, function, inparams, None)
             result = Result(self.iid, request)
             result.set_params(params)
             self.listen_q.put(result)
         time.sleep(0.001)

def main(argv):
	result = Result()
	
	w1 = Worker(0.1, 100, result)
	w1.start()	
	w1.join()
	
	w2 = Worker(0.2, 200, result)
	w2.start()	
	w2.join()
	
	print result.get()
	print "Done."

    def submit_result(self):
        for result in self.get_results():
            if result['score'] > settings.MIN_HOF_SCORE:
                login = result['login']
                if ' ' in login:
                    login = login.split(' ')[0]
                lowest = yield Result.get_last(login, self.board_size)
                if lowest is None or lowest.score < result['score']:
                    result = Result(
                        login=login,
                        score=result['score'],
                        board_size=self.board_size,
                    )

                    yield result.put()

 def __init__(self, xml_state, target_dir, root_dir):
     self.custom_args = None
     self.label = None
     self.root_dir = root_dir
     self.requested_image_type = xml_state.get_build_type_name()
     if self.requested_image_type == 'pxe':
         self.requested_filesystem = xml_state.build_type.get_filesystem()
     else:
         self.requested_filesystem = self.requested_image_type
     if not self.requested_filesystem:
         raise KiwiFileSystemSetupError(
             'No filesystem configured in %s type' %
             self.requested_image_type
         )
     self.filename = ''.join(
         [
             target_dir, '/',
             xml_state.xml_data.get_name(),
             '.' + platform.machine(),
             '-' + xml_state.get_image_version(),
             '.', self.requested_filesystem
         ]
     )
     self.blocksize = xml_state.build_type.get_target_blocksize()
     self.filesystem_setup = FileSystemSetup(xml_state, root_dir)
     self.filesystems_no_device_node = [
         'squashfs'
     ]
     self.result = Result()

    def exit(self):
        """Exit the simulation and create a result file"""

        self.logger.debug("Interruption: exit = " + str(eval(self.config.exit_condition)) +
                          " sim time = " + str(time.time() - self.config.t_init) + " timeout = " + str(
            self.config.timeout))
        self.config.t_end = time.time()

        # Create a result instance and save
        try:
            results = Result(self.body)
            self.logger.info(results)
            results.save_results()
        except Exception as e:
            self.logger.error("Unable to create a result report. Caused by: " + str(e))
            pass

class ArchiveBuilder(object):
    """
        root archive image builder
    """
    def __init__(self, xml_state, target_dir, root_dir):
        self.root_dir = root_dir
        self.target_dir = target_dir
        self.xml_state = xml_state
        self.requested_archive_type = xml_state.get_build_type_name()
        self.result = Result()
        self.filename = self.__target_file_for('tar.xz')
        self.checksum = self.__target_file_for('md5')

    def create(self):
        supported_archives = Defaults.get_archive_image_types()
        if self.requested_archive_type not in supported_archives:
            raise KiwiArchiveSetupError(
                'Unknown archive type: %s' % self.requested_archive_type
            )

        if self.requested_archive_type == 'tbz':
            log.info('Creating XZ compressed tar archive')
            archive = ArchiveTar(
                self.__target_file_for('tar')
            )
            archive.create_xz_compressed(self.root_dir)
            checksum = Checksum(self.filename)
            log.info('--> Creating archive checksum')
            checksum.md5(self.checksum)
            self.result.add(
                'root_archive', self.filename
            )
            self.result.add(
                'root_archive_checksum', self.checksum
            )
        return self.result

    def __target_file_for(self, suffix):
        return ''.join(
            [
                self.target_dir, '/',
                self.xml_state.xml_data.get_name(),
                '.' + platform.machine(),
                '-' + self.xml_state.get_image_version(),
                '.', suffix
            ]
        )

 def test_list_is_sorted(self):
     r = Result()
     r.add("baz", None)
     r.add("bar", None)
     r.add("foo", None)
     r.add("foo", None)
     r.add("baz", None)
     r.add("baz", None)
     self.assertEqual(r.get_list(), [("baz", 3), ("foo", 2), ("bar", 1)])

 def __init__(self, xml_state, target_dir, root_dir):
     self.root_dir = root_dir
     self.target_dir = target_dir
     self.xml_state = xml_state
     self.requested_archive_type = xml_state.get_build_type_name()
     self.result = Result()
     self.filename = self.__target_file_for('tar.xz')
     self.checksum = self.__target_file_for('md5')

class ContainerBuilder(object):
    """
        container image builder
    """
    def __init__(self, xml_state, target_dir, root_dir):
        self.root_dir = root_dir
        self.requested_container_name = xml_state.build_type.get_container()
        self.requested_container_type = xml_state.get_build_type_name()
        self.filename = ''.join(
            [
                target_dir, '/',
                xml_state.xml_data.get_name(),
                '.' + platform.machine(),
                '-' + xml_state.get_image_version(),
                '.', self.requested_container_type, '.tar.xz'
            ]
        )
        self.result = Result()

    def create(self):
        setup_options = {}
        if self.requested_container_name:
            setup_options['container_name'] = self.requested_container_name

        container_setup = ContainerSetup(
            self.requested_container_type, self.root_dir, setup_options
        )
        log.info('Setting up %s container', self.requested_container_type)
        log.info(
            '--> Container name: %s', container_setup.get_container_name()
        )
        container_setup.setup()

        log.info(
            '--> Creating container archive'
        )
        container_image = ContainerImage(
            self.requested_container_type, self.root_dir
        )
        container_image.create(
            self.filename
        )
        self.result.add(
            'container', self.filename
        )
        return self.result

def parse_record(record):
	"""
		Parses a benchmark results record
	"""

	r = Result()
	items = record.split('\n')
	for item in items:
		if 'name' in item.lower():
			name = item.split(':')[1].strip()
			r.name = name
		elif 'elapsed time' in item.lower():
			# Format is like this
			# elapsed time : 123123 seconds
			num = float(item.split(':')[1].strip().split(' ')[0])
			r.elapsed_time += num
		elif 'cpu cycles' in item.lower():
			# Format is like this
			# cpu cycles : 123123
			num = float(item.split(':')[1])
			r.cpu_cycles += num
		# This condition should be above the instructions
		# case to ensure proper parsing
		elif 'branch instructions' in item.lower():
			num = float(item.split(':')[1])
			r.branch_instructions += num
		elif 'ipc' in item.lower():
			num = float(item.split(':')[1])
			r.ipc += num
		elif 'branch misses' in item.lower():
			num = float(item.split(':')[1])
			r.branch_misses += num
		elif 'instructions' in item.lower():
			num = float(item.split(':')[1])
			r.instructions += num
		elif 'branch mispred' in item.lower():
			# Format is like this
			# branch mispred rate: 1.12312%
			percentage = item.split(':')[1]
			num = float(percentage.strip()[:-1]) # remove percentage
			r.branch_mispredict_rate += num				
		else:
			pass
	return r

 def __calculate_rank_points(self):
     start = time.time()
     test = Result(self.name)    
     
     tWiki = Thread(target=test.getWiki)
     tArticles = Thread(target=test.getGoogle)
     tGoogle = Thread(target=test.getFromArticles) 
     
     tWiki.start()
     tArticles.start()
     tGoogle.start()
     
     tWiki.join()
     tArticles.join()
     tGoogle.join()
     
     print self.name + ": " + (str)(time.time() - start) + "s"
     
     return test.getHits()

    def __init__(self):
        FSM.__init__(self, "FSM-Game")
        self.menu = Menu()
        self.gameResult = Result()
        self.numNPCs = 7

        self.musicMenu = loader.loadMusic("Eraplee Noisewall Orchestra - Bermuda Fire.ogg")
        self.musicMenu.setLoop(True)
        self.musicGame = loader.loadMusic("Echovolt - Nothing to Fear.ogg")
        self.musicGame.setLoop(True)

    def create_evaluation(self, reading_system):
        "Create and return a new evaluation, along with an initialized set of result objects."
        from test import Test
        from score import Score
        from result import Result
        from category import Category
        from testsuite import TestSuite

        testsuite = TestSuite.objects.get_most_recent_testsuite()
        print "Creating evaluation for testsuite {0}".format(testsuite.version_date)
        tests = Test.objects.filter(testsuite = testsuite)

        evaluation = self.create(
            testsuite = testsuite,
            last_updated = generate_timestamp(),
            percent_complete = 0.00,
            reading_system = reading_system
        )
        evaluation.save()
        
        total_score = Score(category = None, evaluation = evaluation)
        total_score.save()

        # create results for this evaluation
        for t in tests:
            result = Result(test = t, evaluation = evaluation, result = RESULT_NOT_ANSWERED)
            result.save()

        # update the score once results have been created
        total_score.update(evaluation.get_all_results())

        # create category score entries for this evaluation
        categories = Category.objects.filter(testsuite = evaluation.testsuite)
        for cat in categories:
            score = Score(
                category = cat,
                evaluation = evaluation
            )
            score.update(evaluation.get_category_results(cat))
            score.save()

        return evaluation

 def get(self, board_size='5'):
     """
     Players best results list
     """
     board_size = int(board_size)
     results = yield Result.get_best(board_size)
     if 'html' in self.request.headers.get('Accept', 'html'):
         return self.render(
             'templates/hall_of_fame.html',
             results=results,
             board_size=board_size,
         )