示例#1
0
def main():
    # Check number of the arguments
    algo = 'bubble'
    if len(argv) == 2:
        algo = argv[1]
    elif len(argv) > 2:
        quit_with_usage()

    # Create a new Sorter object and set the algorithm
    sorter = Sorter()
    try:
        sorter.set_algorithm(algo)
    except AlgorithmNotImplementedError:
        print("No such algorithm: %s" % algo)
        quit_with_usage()

    # Doubling Test setting
    trials = 100
    n = 64

    print("# Perform a doubling test for {} sort with {} trials".format(algo, trials))
    print("starting with n = {}".format(n))

    # Time how long it takes to sort
    sorter.generate_new_tuple(n)
    previous = sorter.time_trials(trials)
    print('n: {0:7d} time: {1:7f} (n:n/2) ratio: -'.format(n, previous))

    while True:
        n *= 2
        sorter.generate_new_tuple(n)
        current = sorter.time_trials(trials)
        ratio = float(current / previous)
        print('n: {0:7d} time: {1:7f} (n:n/2) ratio: {2:7f}'.format(n, current, ratio))
        previous = current
示例#2
0
 def test_empty_file(self):
     self.create_file_for_check("")
     sorter = Sorter(input_file_name="test.txt", separators="_", is_bar_need=False)
     sorter.split_file_into_sorted_tmp_files()
     os.chdir(sorter.path_tmp_dir)
     tmp_file_0 = open("0.tmp", "r")
     self.assertEqual("", tmp_file_0.read())
     tmp_file_0.close()
示例#3
0
class TestCompareStrings(unittest.TestCase):
    multisorter = Sorter(input_file_name="", separators="_", is_bar_need=False)
    stable_sorter = Sorter(input_file_name="", separators="_",
                           is_multisorting=False, column_for_sort=2, is_bar_need=False)

    def make_test_multisorting(self, strings):
        self.assertEqual(
            self.multisorter.compare_for_multisorting(strings),
            self.multisorter.compare_strings(strings)
        )

    def make_test_stable_sorting(self, strings):
        self.assertEqual(
            self.stable_sorter.compare_for_stable_sorting(strings),
            self.stable_sorter.compare_strings(strings)
        )

    def test_multisorting(self):
        self.make_test_multisorting([""])
        self.make_test_multisorting(["a"])
        self.make_test_multisorting(["a", "", "b"])
        self.make_test_multisorting(["", "b"])
        self.make_test_multisorting(["4", "tr", "", ""])
        self.make_test_multisorting(["a", "b", "c"])
        self.make_test_multisorting(["a_b_c", "a_b", "a"])
        self.make_test_multisorting(["ab", "aa", "ad"])
        self.make_test_multisorting(["a_bz", "aaaa"])

        self.multisorter.is_reverse = True
        self.make_test_multisorting([""])
        self.make_test_multisorting(["a"])
        self.make_test_multisorting(["a", "", "b"])
        self.make_test_multisorting(["", "b"])
        self.make_test_multisorting(["4", "tr", "", ""])
        self.make_test_multisorting(["a", "b", "c"])
        self.make_test_multisorting(["a_b_c", "a_b", "a"])
        self.make_test_multisorting(["ab", "aa", "ad"])
        self.make_test_multisorting(["a_bz", "aaaa"])

    def test_stable_sorting(self):
        self.make_test_stable_sorting(["a_324_a_a"])
        self.make_test_stable_sorting(["_0_"])
        self.make_test_stable_sorting(["_4_", "aa_45_br_45"])
        self.make_test_stable_sorting(["aa_35_eg", "_7_"])
        self.make_test_stable_sorting(["a_4_b_a", "b_3_a_b"])
        self.make_test_stable_sorting(["b_4_a_b", "b_3_c_b"])
        self.make_test_stable_sorting(["a_4_b_a", "b_3_a_b", "a_0_b_a"])
        self.make_test_stable_sorting(["a_4_bc", "a_12_fx"])

        self.stable_sorter.is_reverse = True
        self.make_test_stable_sorting(["a_324_a_a"])
        self.make_test_stable_sorting(["_0_"])
        self.make_test_stable_sorting(["_4_", "aa_45_br_45"])
        self.make_test_stable_sorting(["aa_35_eg", "_7_"])
        self.make_test_stable_sorting(["a_4_b_a", "b_3_a_b"])
        self.make_test_stable_sorting(["b_4_a_b", "b_3_c_b"])
        self.make_test_stable_sorting(["a_4_b_a", "b_3_a_b", "a_0_b_a"])
        self.make_test_stable_sorting(["a_4_bc", "a_12_fx"])
示例#4
0
def go_sort():
    arr = np.random.randint(1000, size=10).tolist()
    compare_arr = sorted(arr)
    sorter = Sorter()
    assert sorter.sort(arr) == compare_arr
    assert sorter.sort(arr, 'merge') == compare_arr
    assert sorter.sort(arr, 'radix') == compare_arr

    print sorter.sort(arr, args.mode)
示例#5
0
 def __init__(self):
     data_extractor = DataExtractor()
     self.sorter = Sorter(contigs=data_extractor.ctgs,
                          markers=data_extractor.mrkrs)
     self.chr_ctg = self.sorter.chr_ctg_dict()
     self.ctg_fasta = list(Fasta_B10v2_c_corr().generator(
     ))  # namedtuple('FastaRecord', ['id', 'sequence'])
     self.ctg_fasta_dict = self.dict_ctg_fasta()
     self.chr_ctg_order = self.sorter.ctg_order_in_chr()
     self.Contig = namedtuple("Contig", ['id', 'start', 'length', 'seq'])
示例#6
0
    def test_with_4_strig_and_sorting(self):
        self.create_file_for_check(
            "ccc_bbb_aaa\naaa_ccc_bbb\nbbb_ccc_aaa\naaa_bbb_ccc")
        multisorter = Sorter(input_file_name="test.txt", separators="_",
                             strings_in_tmp_file=2, is_bar_need=False)
        stable_sorter = Sorter(input_file_name="test.txt", separators="_",
                               is_multisorting=False, column_for_sort=2,
                               strings_in_tmp_file=2, is_bar_need=False)

        multisorter.split_file_into_sorted_tmp_files()
        os.chdir(multisorter.path_tmp_dir)
        tmp_file_0 = open("0.tmp", "r")
        tmp_file_1 = open("1.tmp", "r")
        self.assertEqual("aaa_ccc_bbb\nccc_bbb_aaa", tmp_file_0.read())
        self.assertEqual("aaa_bbb_ccc\nbbb_ccc_aaa", tmp_file_1.read())
        tmp_file_0.close()
        tmp_file_1.close()

        os.chdir(stable_sorter.path_tmp_dir)
        stable_sorter.split_file_into_sorted_tmp_files()
        tmp_file_0 = open("0.tmp", "r")
        tmp_file_1 = open("1.tmp", "r")
        self.assertEqual("bbb_0_ccc_bbb_aaa\nccc_1_aaa_ccc_bbb",
                         tmp_file_0.read())
        self.assertEqual("bbb_3_aaa_bbb_ccc\nccc_2_bbb_ccc_aaa",
                         tmp_file_1.read())
        tmp_file_0.close()
        tmp_file_1.close()
        self.assertEqual(
            len(stable_sorter.tmp_files_names),
            2
        )
示例#7
0
class TestSortText(unittest.TestCase):
    multisorter = Sorter(input_file_name="", is_reverse=False,
                         is_multisorting=True, separators="_", is_bar_need=False)
    stable_sorter1 = Sorter(input_file_name="", is_reverse=False,
                            is_multisorting=False, separators="_",
                            column_for_sort=2, is_bar_need=False)
    stable_sorter2 = Sorter(input_file_name="", is_reverse=False,
                            is_multisorting=False, separators="_",
                            column_for_sort=2, is_bar_need=False)

    def refresh_sorter(self):
        self.stable_sorter1.string_counter = 0
        self.stable_sorter2.string_counter = 0

    def test_empty_string(self):
        self.refresh_sorter()
        self.assertEqual(
            self.multisorter.multisorting_text(""),
            self.multisorter.sort_text("")
        )
        self.assertEqual(
            self.stable_sorter1.stable_sorting_text(""),
            self.stable_sorter2.sort_text("")
        )

    def test_text_with_single_string(self):
        self.refresh_sorter()
        self.assertEqual(
            self.multisorter.multisorting_text("123_456_789"),
            self.multisorter.sort_text("123_456_789")
        )
        self.assertEqual(
            self.stable_sorter1.stable_sorting_text("123_456_789"),
            self.stable_sorter2.sort_text("123_456_789")
        )

    def test_text_with_any_string(self):
        self.refresh_sorter()
        self.assertEqual(
            self.multisorter.multisorting_text(
                "aaa_1_bbb_aaa_ccc\naaa_2_ccc_aaa_bbb\nbbb_0_aaa_bbb_ccc"),
            self.multisorter.sort_text(
                "aaa_1_bbb_aaa_ccc\naaa_2_ccc_aaa_bbb\nbbb_0_aaa_bbb_ccc")
        )
        self.assertEqual(
            self.stable_sorter1.stable_sorting_text(
                "aaa_1_bbb_aaa_ccc\naaa_2_ccc_aaa_bbb\nbbb_0_aaa_bbb_ccc"),
            self.stable_sorter2.sort_text(
                "aaa_1_bbb_aaa_ccc\naaa_2_ccc_aaa_bbb\nbbb_0_aaa_bbb_ccc")
        )
示例#8
0
class TestMultisortingTest(unittest.TestCase):
    sorter = Sorter(input_file_name='', separators='_', is_bar_need=False)
    sorter_reverse = Sorter(input_file_name='', separators='_',
                            is_reverse=True, is_bar_need=False)

    def test_empty_test(self):
        self.assertEqual(
            '',
            self.sorter.multisorting_text('')
        )
        self.assertEqual(
            '',
            self.sorter_reverse.multisorting_text('')
        )

    def test_text_with_single_string(self):
        self.assertEqual(
            'a_b_c',
            self.sorter.multisorting_text('a_b_c')
        )
        self.assertEqual(
            'c_b_a',
            self.sorter_reverse.multisorting_text('c_b_a')
        )

    def test_text_with_any_strings(self):
        self.assertEqual(
            '1__hy_hiyb\n1_a_ij_j_jo\n2_a_yjtytj',
            self.sorter.multisorting_text(
                '1__hy_hiyb\n2_a_yjtytj\n1_a_ij_j_jo')
        )
        self.assertEqual(
            '2_a_yjtytj\n1_a_ij_j_jo\n1__hy_hiyb',
            self.sorter_reverse
                .multisorting_text('1_a_ij_j_jo\n2_a_yjtytj\n1__hy_hiyb')
        )

    def test_smth_goes_wrong(self):
        self.assertEqual(
            'explode\nexplode acceptable capital explode',
            self.sorter.multisorting_text(
                'explode\nexplode acceptable capital explode')
        )
        self.assertEqual(
            'explode\nexplode acceptable capital explode',
            self.sorter.multisorting_text(
                'explode acceptable capital explode\nexplode')
        )
示例#9
0
 def saveConfFile(self):
     confBackupFilePath = os.path.join(self.scriptDir, "conf.bak")
     if os.path.exists(confBackupFilePath):
         os.remove(confBackupFilePath)
     shutil.copy2(os.path.join(self.scriptDir, "conf.conf"),
                  os.path.join(self.scriptDir, "conf.bak"))
     confFile = open(os.path.join(self.scriptDir, "conf.conf"),
                     "w",
                     encoding="utf-8")
     listKeys = sorted(self.guiStrings.values(), key=attrgetter('order'))
     for key in listKeys:
         if key.id not in ['verify', 'save', 'proceed', 'confirm']:
             if key.help:
                 confFile.write('# ' + key.help.replace('#n', '\n# ') +
                                '\n')
             if key.id == 'images':
                 imagesValue = self.guiVars[self.guiStrings['images'].label
                                            + ' #1'].get()
                 if self.guiStrings['images'].label + ' #2' in self.guiVars:
                     imagesValue = imagesValue + '|' + self.guiVars[
                         self.guiStrings['images'].label + ' #2'].get()
                 confFile.write(key.id + ' = ' + imagesValue + '\n')
             elif key.id == 'keepLevel':
                 confFile.write(
                     key.id + ' = ' +
                     str(Sorter.getIntStatus(self.guiVars[key.id].get())) +
                     '\n')
             else:
                 if key.id in self.guiVars:
                     confFile.write(key.id + ' = ' +
                                    str(self.guiVars[key.id].get()) + '\n')
     confFile.close()
     self.logger.log('    Configuration saved in conf.conf file')
示例#10
0
 def make_test(self, text, result):
     tmp_dir = tempfile.mkdtemp()
     os.chdir(tmp_dir)
     tmp_file = open("4.tmp", "w")
     tmp_file.write(text)
     tmp_file.close()
     sorter = Sorter(input_file_name="", separators="_",
                     is_multisorting=False, column_for_sort=2, is_bar_need=False)
     sorter.path_tmp_dir = tmp_dir
     sorter.prepare_stable_sorting_file_to_replace("4.tmp")
     tmp_file = open("4.tmp", "r")
     self.assertEqual(
         result,
         tmp_file.read()
     )
     tmp_file.close()
示例#11
0
    def __init__(self, tamp):
        self.tamp = tamp

        #motor left
        self.motorL = Motor(self.tamp, 2, 4)
        self.motorL.write(1, 0)

        #motor right
        self.motorR = Motor(self.tamp, 1, 3)
        self.motorR.write(1, 0)

        #arm servo
        self.arm = Arm(self.tamp)

        #sorting servo
        self.sorter = Sorter(self.tamp)
示例#12
0
    def test_sortcrawl_sd_dir(self):
        with Sorter(db_handler=self.db_handler) as sortbot9k:
            sortbot9k.scrape_directories(self.sd_directory)
            sortbot9k.sort_onions(self.class_tests)

        uptodate_class, uptodate_name = \
                self.db_handler.get_onion_class(self.get_cur_runtime(), True)
        self.assertEqual(type(uptodate_class), dict)
        # At least 10 of our instances should be on the latest version
        self.assertGreaterEqual(len(uptodate_class), 10)
        self.assertRegex(list(uptodate_class)[0], "http")
        self.assertRegex(list(uptodate_class)[0], ".onion")

        outofdate_class, outofdate_name = \
                self.db_handler.get_onion_class(self.get_cur_runtime(), False)
        self.assertEqual(type(outofdate_class), dict)
        # At least 1 of our instances will be lagging behind versions :'(
        self.assertGreaterEqual(len(outofdate_class), 1)
        self.assertRegex(list(outofdate_class)[0], "http")
        self.assertRegex(list(outofdate_class)[0], ".onion")

        class_data = self.db_handler.get_onions(self.get_cur_runtime())
        nonmonitored_name, monitored_name = class_data.keys()
        # Test that we get the expected class names, and data types back
        self.assertEqual(nonmonitored_name, 'nonmonitored')
        self.assertRegex(monitored_name, 'sd')
        nonmonitored_class, monitored_class = class_data.values()
        self.assertEqual(type(nonmonitored_class), dict)
        self.assertEqual(type(monitored_class), dict)

        with Crawler(db_handler=self.db_handler) as crawlbot9k:
            crawlbot9k.collect_set_of_traces(nonmonitored_class)
示例#13
0
文件: main.py 项目: michalatwi/wi-ft
 def run(self):
     parser = MovieIdParser(self.moviecount)
     parser.run_parser()
     fetcher = MovieDataFetcher(parser.idcontainer)
     fetcher.run()
     sortedmovies = Sorter.sort_by_year(fetcher.fullmoviesdata)
     #Save.save_to_csv(sortedmovies, self.file)
     Save.save_to_db(sortedmovies)
示例#14
0
class TestStableSortingTest(unittest.TestCase):
    sorter = Sorter(separators='_', is_multisorting=False, column_for_sort=2,
                    input_file_name="", is_bar_need=False)
    sorter_reverse = Sorter(separators='_', is_reverse=True,
                            is_multisorting=False, column_for_sort=2,
                            input_file_name="", is_bar_need=False)

    def refresh_sorters(self):
        self.sorter.string_counter = 0
        self.sorter_reverse.string_counter = 0

    def test_empty_text(self):
        self.refresh_sorters()
        self.assertEqual(
            "",
            self.sorter.stable_sorting_text("")
        )
        self.assertEqual(
            "",
            self.sorter_reverse.stable_sorting_text("")
        )

    def test_text_with_single_string(self):
        self.refresh_sorters()
        self.assertEqual(
            "456_0_123_456_789",
            self.sorter.stable_sorting_text("123_456_789")
        )
        self.assertEqual(
            "456_0_123_456_789",
            self.sorter_reverse.stable_sorting_text("123_456_789")
        )

    def test_any_text(self):
        self.refresh_sorters()
        self.assertEqual(
            "aaa_1_bbb_aaa_ccc\naaa_2_ccc_aaa_bbb\nbbb_0_aaa_bbb_ccc",
            self.sorter.stable_sorting_text(
                "aaa_bbb_ccc\nbbb_aaa_ccc\nccc_aaa_bbb")
        )
        self.assertEqual(
            "bbb_0_aaa_bbb_ccc\naaa_2_ccc_aaa_bbb\naaa_1_bbb_aaa_ccc",
            self.sorter_reverse.stable_sorting_text(
                "aaa_bbb_ccc\nbbb_aaa_ccc\nccc_aaa_bbb")
        )
示例#15
0
    def test_sort(self):
        all_m = ProcessRegex.all_matches(self.regex1, self.list_tring)
        sorter = Sorter(SortMethod.abc, SortOrder.asc)
        list_s = sorter.beginSorting(all_m)
        self.assertEqual(list_s[3], "*****@*****.**")
        self.assertEqual(list_s[14], "*****@*****.**")

        sorter = Sorter(SortMethod.abc, SortOrder.desc)
        list_s = sorter.beginSorting(all_m)
        self.assertEqual(list_s[0], "*****@*****.**")

        sorter = Sorter(SortMethod.freq, SortOrder.asc)
        list_s = sorter.beginSorting(all_m)
        self.assertEqual(list_s[0], "*****@*****.**")
示例#16
0
    def make_test(self, texts, count_of_merging, result, reverse=False,
                  multisorting=True):
        sorter = Sorter(input_file_name="", separators="_", is_reverse=reverse,
                        is_multisorting=multisorting, column_for_sort=2, is_bar_need=False)
        self.prepare_to_check(sorter, texts)
        tmp_files_counter = sorter.tmp_file_counter
        sorter.merging_any_tmp_files(count_of_merging)
        self.assertTrue(sorter.tmp_file_counter - 1 == tmp_files_counter)

        self.assertTrue(
            len(sorter.tmp_files_names) == len(texts) - count_of_merging + 1)
        self.assertTrue(str(len(texts)) + ".tmp" in sorter.tmp_files_names)
        result_file = open(str(len(texts)) + ".tmp", 'r')
        self.assertEqual(
            result,
            result_file.read()
        )
        result_file.close()
示例#17
0
class SorterTests(unittest.TestCase):

	def setUp(self):
		self._unsorted = [7,2,1,8,11,5,3,4]
		self._sorted   = [1,2,3,4,5,7,8,11]
		self.sorter = Sorter()

	def test_bubbleSort(self):
		self.assertEqual(self._sorted, self.sorter.bubble_sort(self._unsorted))

	def test_selectionSort(self):
		self.assertEqual(self._sorted, self.sorter.selection_sort(self._unsorted))

	def test_insertionSort(self):
		self.assertEqual(self._sorted, self.sorter.insertion_sort(self._unsorted))
	
	def test_shellSort(self):
		self.assertEqual(self._sorted, self.sorter.shell_sort(self._unsorted))
示例#18
0
 def setUpClass(cls):
     cls.sorter = Sorter({
         'alex': 1120,
         'andre': -130,
         'bernhard': 3000,
         'david': 5460,
         'petra': 1120,
         'olga': 1120
     })
示例#19
0
 def clickProceed(self) :
     self.logger.log('\n<--------- Starting Process --------->')
     self.saveConfInMem()
     message=self.guiStrings['confirm'].help.replace('{outputDir}',self.guiVars['exportDir'].get()).replace('#n','\n')
     result = messagebox.askokcancel(self.guiStrings['confirm'].label,message)
     if result :
         self.verifyButton['state'] = 'disabled'
         self.saveButton['state'] = 'disabled'
         self.proceedButton['state'] = 'disabled'
         self.logger.log('\n<--------- Starting Process --------->')
         sorter = Sorter(self.configuration,self.scriptDir,self.logger)
         _thread.start_new(sorter.process,())
示例#20
0
    def do_tests(self, texts, result):
        sorter = Sorter(input_file_name="", separators="_", is_bar_need=False)
        tmp_dir = tempfile.mkdtemp()
        os.chdir(tmp_dir)
        sorter.path_tmp_dir = tmp_dir
        counter = 0
        for text in texts:
            input_file = open(str(counter) + ".tmp", "w")
            counter += 1
            sorter.tmp_file_counter += 1
            sorter.tmp_files_names.append(input_file.name)
            input_file.write(text)
            input_file.close()

        sorter.merging_all_tmp_files()
        result_file = open(sorter.tmp_files_names[0], 'r')
        self.assertEqual(
            result,
            result_file.read()
        )
        result_file.close()
示例#21
0
class Actuators:
	def __init__(self,tamp):
		self.tamp=tamp
				
		#motor left
		self.motorL = Motor(self.tamp, 2, 4)
		self.motorL.write(1,0)

		#motor right
		self.motorR = Motor(self.tamp,1, 3)
		self.motorR.write(1,0)

		#arm servo
		self.arm = Arm(self.tamp)

		#sorting servo
		self.sorter = Sorter(self.tamp)

	def update(self):
		self.arm.update()
		self.sorter.update()
示例#22
0
class Actuators:
    def __init__(self, tamp):
        self.tamp = tamp

        #motor left
        self.motorL = Motor(self.tamp, 2, 4)
        self.motorL.write(1, 0)

        #motor right
        self.motorR = Motor(self.tamp, 1, 3)
        self.motorR.write(1, 0)

        #arm servo
        self.arm = Arm(self.tamp)

        #sorting servo
        self.sorter = Sorter(self.tamp)

    def update(self):
        self.arm.update()
        self.sorter.update()
示例#23
0
文件: main.py 项目: dmarchewka/sorter
    def run(self):
        # Read file
        file_reader = FileReader(self.file_path)
        file_reader.parse()

        # Store output in data object
        data = Data(raw_data=file_reader.result)

        # Sort data
        sorter = Sorter(raw_data=file_reader.result)
        sorter.create_time_employee()
        sorter.create_time_sorted()

        # Store sorted data in data object
        data.time_employee = sorter.time_employee
        data.time_sorted = sorter.time_sorted

        # Create statistics
        stats = StatsGenerator(data)
        stats.calculate_average_working_time()

        # Write data to files
        file_writer = FileWriter(data, stats.get_statistics)
        file_writer.create_stats_output()
        file_writer.create_data_output()
        file_writer.write2json()
        file_writer.write2cvs()
示例#24
0
class ContigsCompleteData():
    def __init__(self):
        data_extractor = DataExtractor()
        self.sorter = Sorter(contigs=data_extractor.ctgs,
                             markers=data_extractor.mrkrs)
        self.chr_ctg = self.sorter.chr_ctg_dict()
        self.ctg_fasta = list(Fasta_B10v2_c_corr().generator(
        ))  # namedtuple('FastaRecord', ['id', 'sequence'])
        self.ctg_fasta_dict = self.dict_ctg_fasta()
        self.chr_ctg_order = self.sorter.ctg_order_in_chr()
        self.Contig = namedtuple("Contig", ['id', 'start', 'length', 'seq'])

    def dict_ctg_fasta(self):
        return {ctg.id: ctg.sequence for ctg in self.ctg_fasta}

    def chr_sumCtgLen(self):
        ''' dict {chr: sum(ctg_len}'''
        ret = {}
        for chr in self.chr_ctg:
            ret[chr] = sum([ctg['contig_length'] for ctg in self.chr_ctg[chr]])
        return ret

    def sum_ctg_exel(self):
        chr_sumCtg = self.chr_sumCtgLen()
        return sum([chr_sumCtg[chr] for chr in chr_sumCtg.keys()])

    def sum_ctg_fasta(self):
        ''' :return sum contigs from gff file'''
        return sum([len(fasta.sequence) for fasta in self.ctg_fasta])

    def percent_known_genome(self):
        return self.sum_ctg_exel() / float(self.sum_ctg_fasta())

    @staticmethod
    def convert_int_to_ctg_id(id):
        return "ctg" + str(id)

    @staticmethod
    def convert_ctgId_to_int(ctg_id):
        return ctg_id[3:]
示例#25
0
    def test_multisort(self):
        with open('file.txt', 'w')as file:
            for i in range(11):
                file.write(str(i) + '\n')

        s = Sorter('file.txt')
        s.sort()
        sorted = get_text('file.txt')
        self.assertEqual(sorted, ['0', '1', '10', '2', '3', '4', '5', '6', '7', '8', '9'])

        s = Sorter('file.txt', is_reversible=True)
        s.sort()
        sorted = get_text('file.txt')
        self.assertEqual(sorted, ['9', '8', '7', '6', '5', '4', '3', '2', '10', '1', '0'])

        os.remove('file.txt')
示例#26
0
 def __init__(self, environment):
     """default constructor"""
     super(Main_Manager, self).__init__("main_manager", environment)
     self.inv_editor = Inv_Editor()
     self.login_controller = Login_Controller()
     self.searcher = Searcher()
     self.sorter = Sorter()
     self.username_entry = None
     self.password_entry = None
     self.main_menu = Main_Menu()
     self.working = True
     self.username = ""
     self.password = ""
     self.initialize_DB()
示例#27
0
 def __clickProceed(self):
     self.logger.log('\n<--------- Saving retroarch configuration --------->')
     self.__saveConfInMem()
     message = self.guiStrings['confirm'].help.replace('{outputDir}', self.guiVars['exportDir'].get()).replace('#n',
                                                                                                               '\n')
     result = messagebox.askokcancel(self.guiStrings['confirm'].label, message)
     if result:
         self.verifyButton['state'] = 'disabled'
         self.saveButton['state'] = 'disabled'
         self.proceedButton['state'] = 'disabled'
         self.mummy.disableOtherTabs('retroarch', self.hardware)
         self.logger.log('\n<--------- Starting retroarch Process --------->')
         sorter = Sorter(self.configuration, self.scriptDir, partial(self.postProcess), self.logger, self.hardware)
         _thread.start_new(sorter.process, ())
示例#28
0
	def createMasterInspectionXML(self, delChildXMLs = False):
		lt = ListTool()
		os = OSTool()
		sort = Sorter()
		insp = Inspector()

		xmls = os.getFilesInDir('results/')
		xmls = lt.popByWord(xmls, self.masterInspectionPath)

		XMLInspections = insp.getInspections(xmls)				

		if len(XMLInspections) == 0:
			print('No files read.')
			exit()

		XMLInspections = sort.sortInspectionList(XMLInspections)

		xWriter = XMLWriter()
		xWriter.writeMIXML(XMLInspections, self.masterInspectionPath)

		if delChildXMLs:
			for xml in xmls:
				os.deleteFile(xml)
示例#29
0
 def saveConfInMem(self) :
     listKeys = sorted(self.guiStrings.values(), key=attrgetter('order'))        
     for key in listKeys :
         if key.id not in ['verify','save','proceed','confirm'] :                
             if key.id == 'images' :
                 imagesValue = self.guiVars[self.guiStrings['images'].label+' #1'].get()
                 if self.guiStrings['images'].label+' #2' in self.guiVars :
                     imagesValue = imagesValue + '|' + self.guiVars[self.guiStrings['images'].label+' #2'].get()
                 self.configuration['images']=  imagesValue
             elif key.id == 'keepLevel' :
                 self.configuration['keepLevel'] = str(Sorter.getIntStatus(self.guiVars[key.id].get()))
             else :                
                 if key.id in self.guiVars :
                     self.configuration[key.id] = str(self.guiVars[key.id].get())
     self.logger.log('    Configuration saved in memory')       
示例#30
0
    def test_file_with_single_string(self):
        self.create_file_for_check("1_2_345_a")
        multisorter = Sorter(input_file_name="test.txt", separators="_", is_bar_need=False)
        stable_sorter = Sorter(input_file_name="test.txt", separators="_",
                               is_multisorting=False, column_for_sort=2, is_bar_need=False)

        multisorter.split_file_into_sorted_tmp_files()
        os.chdir(multisorter.path_tmp_dir)
        tmp_file_0 = open("0.tmp", "r")
        self.assertEqual("1_2_345_a", tmp_file_0.read())
        tmp_file_0.close()

        stable_sorter.split_file_into_sorted_tmp_files()
        os.chdir(stable_sorter.path_tmp_dir)
        tmp_file_0 = open("0.tmp", "r")
        self.assertEqual("2_0_1_2_345_a", tmp_file_0.read())
        tmp_file_0.close()
示例#31
0
	def __init__(self,tamp):
		self.tamp=tamp
				
		#motor left
		self.motorL = Motor(self.tamp, 2, 4)
		self.motorL.write(1,0)

		#motor right
		self.motorR = Motor(self.tamp,1, 3)
		self.motorR.write(1,0)

		#arm servo
		self.arm = Arm(self.tamp)

		#sorting servo
		self.sorter = Sorter(self.tamp)
示例#32
0
    def test_million_strings(self):
        f = None
        try:
            f = open('million.txt', 'r')
        except:
            pass
        if f is not None:
            f.close()
            s = Sorter('million.txt')
            s.sort()
            f = open('million.txt', 'r')
            self.assertEqual(f.read(1), ' ')
            f.close()

            s = Sorter('million.txt',is_reversible=True)
            s.sort()
            f= open('million.txt', 'r')
            self.assertEqual(f.read(1), 'Z')
            f.close()
示例#33
0
文件: sam.py 项目: sergree/samwell
    def __init__(self, **options):
        super().__init__(**options)

        self.main_guild = None
        self.main_channel = None
        self.command_channel = None
        self.create_voice_channel = None

        self.color_change_message = None
        self.invite_create_message = None
        self.shuffle_roles_message = None
        self.command_messages = {}

        self.color_roles = {}

        self.sorter = Sorter()
        self.inviter = Inviter()
        self.referral_patrol = ReferralPatrol()
        self.channel_creator = VoiceChannelCreator()
示例#34
0
class TestMakeAndDeleteTmpDir(unittest.TestCase):
    sorter = Sorter(separators='', input_file_name='', is_bar_need=False)

    def test_all(self):
        self.create_tmp_dir_test()
        self.delete_tmp_dir_test()

    def create_tmp_dir_test(self):
        self.sorter.make_tmp_dir(None)
        tmp_dir_name = re.split('[\\\|/]', self.sorter.path_tmp_dir)[
            len(re.split('[\\\|/]', self.sorter.path_tmp_dir)) - 1]
        self.assertTrue(tmp_dir_name in os.listdir(tempfile.gettempdir()))

    def delete_tmp_dir_test(self):
        self.sorter.delete_tmp_dir()
        tmp_dir_name = re.split('[\\\|/]', self.sorter.path_tmp_dir)[
            len(re.split('[\\\|/]', self.sorter.path_tmp_dir)) - 1]
        self.assertFalse(
            tmp_dir_name in os.listdir(tempfile.gettempdir()))
def main():

    keyword = str(input('please input keyword\n'))
    targetSite = str(input('please input target site\n'))

    if keyword == '':
        print('no keyword')

    else:
        if isFilterWanted():
            filter = Filter()
            filter.set()
        else:
            filter = Filter()

        if isSortWanted():
            sorter = Sorter()
            sorter.set()
        else:
            sorter = Sorter()

        if targetSite.lower() == 'pchome':
            search.searchOnPChome(keyword, filter, sorter)

        elif targetSite.lower() == 'shopee' or targetSite.lower(
        ) == 'xiapi' or targetSite == '蝦皮':
            search.searchOnShopee(keyword, filter, sorter)

        elif targetSite.lower() == 'qoo10':
            search.searchOnQoo10(keyword, filter, sorter)

        elif targetSite.lower() == 'etmall' or targetSite == '東森':
            search.searchOnEtmall(keyword, filter, sorter)

        elif targetSite.lower() == 'rakuten' or targetSite == '樂天':
            search.searchOnRakuten(keyword, filter, sorter)

        elif targetSite.lower() == 'all':
            search.searchOnPChome(keyword, filter, sorter)
            search.searchOnShopee(keyword, filter, sorter)
            search.searchOnQoo10(keyword, filter, sorter)
            search.searchOnEtmall(keyword, filter, sorter)

        elif targetSite.lower() == 'exit':
            exit()

        else:
            print('target site is not supported\nPlease input again or exit')
            main()  #recursive
示例#36
0
 def do_test(self):
     tmp_dir = tempfile.mkdtemp()
     os.chdir(tmp_dir)
     self.create_random_file("test.txt", 5000, 30)
     sorter = Sorter(input_file_name="test.txt", separators=" ", is_bar_need=False)
     sorter.strings_in_tmp_file = 50
     sorter.sort()
     result_file = open("test.txt", 'r')
     previous_string = result_file.readline().replace("\n", "")
     current_string = result_file.readline().replace("\n", "")
     while current_string != "":
         self.assertEqual(0, sorter.compare_strings(
             [previous_string, current_string]))
         previous_string = current_string
         current_string = result_file.readline().replace("\n", "")
     result_file.close()
示例#37
0
	def setUp(self):
		self._unsorted = [7,2,1,8,11,5,3,4]
		self._sorted   = [1,2,3,4,5,7,8,11]
		self.sorter = Sorter()
示例#38
0
	def writeNewMasterInspectionXML(self):
		sort = Sorter()
		self.XMLInspections = sort.sortInspectionList(self.XMLInspections)
		xWriter = XMLWriter()
		xWriter.writeMIXML(self.XMLInspections, self.masterInspectionPath)