def run_evosuite(evosuite_jar_path, strategy, projectCP, class_name, criterion, epa_path, inferred_epa_xml_path, stopping_condition, search_budget, test_dir='test', report_dir='report'): #is_JDBCResultSet = "JDBCResultSet" in class_name #extra_parameters = "-Dassertions=\"false\" -Dminimize=\"false\"" if is_JDBCResultSet else "" #extra_parameters = "-Dminimize=\"false\"" extra_parameters = "-Dminimize=\"true\" -Dstop_zero=\"false\" -Djunit_allow_restricted_libraries=true -Duse_separate_classloader=\"false\" -Dwrite_covered_goals_file=\"false\" -Dwrite_all_goals_file=\"false\" -Dtest_archive=\"true\" -Dprint_missed_goals=\"true\" -Dno_runtime_dependency=\"true\" -Dshow_progress=\"false\" -Dassertions=\"true\" -Dcoverage=\"true\" -Dallows_actions_violates_precondition=\"false\"" output_parameters = "-Doutput_variables=\"TARGET_CLASS,criterion,Coverage,Total_Goals,Covered_Goals,Generations,Total_Time\"" #-Dextra_timeout=\"600\" for subjects as strbuilder timeout_parameters = "-Dtimeout=\"4000\" -Djunit_check_timeout=\"600\" -Dassertion_timeout=\"600\" -Dminimization_timeout=\"600\" -Dextra_timeout=\"600\"" command = 'java -jar {} -projectCP {} -class {} -criterion {} -mem=\"4096\" -Dstopping_condition={} -Dsearch_budget={} {} -Dp_functional_mocking=\"0.0\" -Dfunctional_mocking_percent=\"0.0\" -Dvirtual_fs=\"false\" -Dp_reflection_on_private=\"0.0\" -Dtest_dir={} -Dreport_dir={} -Depa_xml_path={} -Dinferred_epa_xml_path={} {} {} {} > {}gen_out.txt 2> {}gen_err.txt'.format( evosuite_jar_path, projectCP, class_name, criterion, stopping_condition, search_budget, strategy, test_dir, report_dir, epa_path, inferred_epa_xml_path, extra_parameters, output_parameters, timeout_parameters, test_dir, test_dir) utils.print_command(command) try: subprocess.check_output(command, shell=True) except Exception as e: print( "Error al correr evosuite en la generacion de test con el comando '{}'. Error {}" .format(command, e))
def run_randoop(projectCP, class_name, randoop_jar_path, testdir, search_budget): def remove_randoop_error_test(testdir): for test in os.listdir(testdir): if "ErrorTest" in test: test_file = os.path.join(testdir, test) os.unlink(test_file) #if not test_file.endswith(".java"): # continue #if not test[-1:].isdigit(): # Randoop generates a test file without tests. # continue """def change_class_name(test_dir, new_classname): utils.rename_class(test_dir, "RegressionTest", new_classname)""" utils.make_dirs_if_not_exist(testdir) sep = os.path.pathsep err_file = os.path.join(testdir, "err.txt") out_file = os.path.join(testdir, "out.txt") package = class_name.split(".")[0:-1] packages_dir = utils.get_package_dir(package) command = 'java -classpath {}{}{} randoop.main.Main gentests --testclass={} --time-limit={} --usethreads=true --junit-package-name={} --npe-on-non-null-input=expected --junit-output-dir={} > {} 2> {}'.format( projectCP, sep, randoop_jar_path, class_name, search_budget, packages_dir.replace(os.path.sep, ".")[:-1], testdir, out_file, err_file) utils.print_command(command) try: subprocess.check_output(command, shell=True) except Exception as e: print("Error al correr randoop con el comando '{}'".format(command, e)) testdir_full = os.path.join(testdir, packages_dir) remove_randoop_error_test(testdir_full)
def get_file_path_jncss(strategy, class_name, test_dir, results_dir_name, bug_type, stopping_condition, search_budget, criterion, runid, javancss_jar_path): package = class_name.split(".")[0:-1] package_dir = utils.get_package_dir(package) if "randoop".upper() in criterion.upper(): only_class_name = "RegressionTest?.java" #Randoop genera varios .java, c/u con 500 tests else: only_class_name = class_name.split(".")[-1] + "_ESTest.java" test_suite_file_path = os.path.join(test_dir, package_dir, only_class_name) result_jncss_temp = os.path.join( results_dir_name, "javancss_temp", "{}_{}_{}_{}_{}_{}".format(strategy, bug_type, stopping_condition, search_budget, class_name, criterion)) utils.make_dirs_if_not_exist(result_jncss_temp) result_jncss_temp = os.path.join(result_jncss_temp, "{}.txt".format(runid)) command = "java -jar {} {} > {}".format(javancss_jar_path, test_suite_file_path, result_jncss_temp) utils.print_command(command) utils.lock_if_windows() try: subprocess.check_output(command, shell=True) except Exception as e: print("Error al ejecutar el comando '{}'. Error {}".format(command, e)) finally: utils.release_if_windows() return result_jncss_temp
def run_pitest(workdir): command = "mvn clean install org.pitest:pitest-maven:mutationCoverage > {}out.txt 2> {}err.txt".format( workdir, workdir) #Si quiero evitar limpiar lo generado (util para dejar algunas classya generados y usar eso para correr PIT #command = "mvn install org.pitest:pitest-maven:mutationCoverage > {}out.txt 2> {}err.txt".format(workdir, workdir) utils.print_command(command, workdir) try: subprocess.check_output(command, cwd=workdir, shell=True) except Exception as e: print("Error al correr pitest con el comando '{}'. Error {}".format( command, e))
def solve(stage): position, label = get_position_or_label(stage, display(stage)) if position is not None: print_command(f'position {position}') else: print_command(f'label {label}') if stage < 5: if label is None: label = input_number('Label: ', size=1) else: position = input_number('Position: ', size=1) next_button(position, label) print()
def measure_evosuite(evosuite_jar_path, projectCP, testCP, class_name, epa_path, report_dir, criterion): utils.make_dirs_if_not_exist(report_dir) err_file = os.path.join(report_dir, criterion.replace(":", "_") + "_err.txt") out_file = os.path.join(report_dir, criterion.replace(":", "_") + "_out.txt") sep = os.path.pathsep command = 'java -jar {}evosuite-master-1.0.4-SNAPSHOT.jar -projectCP {}{}{} -class {} -Depa_xml_path={} -criterion {} -Dwrite_covered_goals_file=\"true\" -Dwrite_all_goals_file=\"true\" -Dreport_dir={} -measureCoverage > {} 2> {}'.format( evosuite_jar_path, projectCP, sep, testCP, class_name, epa_path, criterion, report_dir, out_file, err_file) utils.print_command(command) subprocess.check_output(command, shell=True)
def copy_pitest_csv(name, workdir, all_report_dir): command = utils.find_and_save_command("*.csv", "sources.txt") utils.print_command(command, workdir) utils.lock_if_windows() subprocess.check_output(command, cwd=workdir, shell=True) utils.release_if_windows() with open(os.path.join(workdir, "sources.txt")) as file: for line in file: file_path = os.path.join(workdir, line[2:-1]) if 'mutations' in line: copy_csv(file_path, '{}_mutations'.format(name), all_report_dir) elif 'jacoco' in line: copy_csv(file_path, '{}_jacoco'.format(name), all_report_dir)
def settings(): global direction, PIN DIRECTIONS = {'0': 'North', '1': 'East', '2': 'South', '3': 'West'} def get_direction(): serial = '' while len(serial) < 2: serial = input('First 2 characters of Serial#: ') serial = serial[:2] if serial[0].isdigit(): if serial[1].isdigit(): return 3 return 2 if serial[1].isdigit(): return 1 return 0 if direction is None: # Obtain direction direction = get_direction() if ask('Parallel port?'): direction = ((direction - 1) + 4) % 4 # move counter-clockwise elif ask('Serial port?'): direction = (direction + 1) % 4 # move clockwise direction_name = DIRECTIONS[str(direction)] print_info(direction_name) def append_pin_digit(apps, msg): global PIN print_apps(apps) app = input_app(apps, msg) PIN += str(APPS[app]) apps.remove(app) remaining = remaining_apps() if len(remaining) == 1 and remaining[0] == 'Settings': # Determine order of submission apps = set(APPS.keys()) append_pin_digit(apps, f'App ({direction_name} from center)') while len(apps) > 1: append_pin_digit(apps, 'Next App (Clockwise)') if len(apps) == 1: PIN += str(APPS[apps.pop()]) print_command(f'submit {PIN}') else: print_info('Solve remaining apps before submit')
def run_evosuite(evosuite_jar_path, projectCP, class_name, criterion, epa_path, stopping_condition, search_budget, test_dir='test', report_dir='report'): #is_JDBCResultSet = "JDBCResultSet" in class_name #extra_parameters = "-Dassertions=\"false\" -Dminimize=\"false\"" if is_JDBCResultSet else "" command = 'java -jar {}evosuite-master-1.0.4-SNAPSHOT.jar -projectCP {} -class {} -criterion {} -Dstopping_condition={} -Dsearch_budget={} -Djunit_allow_restricted_libraries=true -Dp_functional_mocking=\"0.0\" -Dp_reflection_on_private=\"0.0\" -Duse_separate_classloader=\"false\" -Dwrite_covered_goals_file=\"false\" -Dwrite_all_goals_file=\"false\" -Dprint_missed_goals=\"true\" -Dtest_dir={} -Dreport_dir={} -Depa_xml_path={} -Dno_runtime_dependency=\"true\" -Dshow_progress=\"false\" -Dtimeout="300" -Doutput_variables=\"TARGET_CLASS,criterion,Coverage,Total_Goals,Covered_Goals,Generations,Total_Time\" -Dassertions=\"true\" -Dminimize=\"true\" -Dcoverage=\"true\" -Djunit_check_timeout="600" -Dassertion_timeout="600" > {}gen_out.txt 2> {}gen_err.txt'.format( evosuite_jar_path, projectCP, class_name, criterion, stopping_condition, search_budget, test_dir, report_dir, epa_path, test_dir, test_dir) utils.print_command(command) subprocess.check_output(command, shell=True)
def measure_evosuite(evosuite_jar_path, projectCP, testCP, class_name, epa_path, report_dir, criterion, inferred_epa_xml_path, force_inferred_epa): utils.make_dirs_if_not_exist(report_dir) err_file = os.path.join(report_dir, criterion.replace(":", "_") + "_err.txt") out_file = os.path.join(report_dir, criterion.replace(":", "_") + "_out.txt") sep = "" if projectCP[-1] == os.path.pathsep else os.path.pathsep command = 'java -jar {} -projectCP {}{}{} -class {} -Depa_xml_path={} -criterion {} -Dwrite_covered_goals_file=\"true\" -Dwrite_all_goals_file=\"true\" -Dreport_dir={} -Dforce_inferred_epa={} -Dinferred_epa_xml_path={} -Dallows_actions_violates_precondition=\"false\" -measureCoverage > {} 2> {}'.format( evosuite_jar_path, projectCP, sep, testCP, class_name, epa_path, criterion, report_dir, force_inferred_epa, inferred_epa_xml_path, out_file, err_file) utils.print_command(command) try: subprocess.check_output(command, shell=True) except Exception as e: print( "Error al correr evosuite en la medicion de cobertura con el comando '{}'" .format(command, e))
def pitest_measure(pitest_dir, targetClasses, targetTests, class_dir, test_dir): generate_pitest_workdir(pitest_dir) edit_pit_pom('pit_pom.xml', targetClasses, targetTests, os.path.join(pitest_dir, "pom.xml")) pitest_dir_src_main_java = os.path.join(pitest_dir, "src", "main", "java") command_copy_source = 'cp -r {}/* {}'.format(class_dir, pitest_dir_src_main_java) utils.print_command(command_copy_source) # Si existe el directorio lo elimino (sino tira error shutil.copytree) if os.path.exists(pitest_dir_src_main_java): shutil.rmtree(pitest_dir_src_main_java) shutil.copytree(class_dir, pitest_dir_src_main_java) pitest_dir_src_test_java = os.path.join(pitest_dir, "src", "test", "java") command_copy_test = 'cp -r {}/* {}'.format(test_dir, pitest_dir_src_test_java) utils.print_command(command_copy_test) if os.path.exists(pitest_dir_src_test_java): shutil.rmtree(pitest_dir_src_test_java) shutil.copytree(test_dir, pitest_dir_src_test_java) run_pitest(os.path.join(pitest_dir, ""))
current = prev prev = previous[current[0]][current[1]] path.append(('S', start_pos)) path.reverse() return path # BFS q = deque() q.append(start_pos) while len(q) > 0: pos = q.popleft() for neighbour in get_neighbours(pos): if previous[neighbour[0]][neighbour[1]] is None: previous[neighbour[0]][neighbour[1]] = pos if neighbour == end_pos: return build_path() q.append(neighbour) if __name__ == "__main__": start = input('Display: ') end = input('Last digit of Serial#: ') path = get_path(start, end) if path: dir_path = ''.join(list(map(lambda dir_pos: dir_pos[0], path[1:]))) dir_path = dir_path[::2] # Remove wall rows/cols print_command(dir_path) else: print_info('No solution. Please check input.')
def run_pitest(workdir): command = "mvn clean install org.pitest:pitest-maven:mutationCoverage > {}out.txt 2> {}err.txt".format( workdir, workdir) utils.print_command(command, workdir) subprocess.check_output(command, cwd=workdir, shell=True)
def run(self): if self.method in [ EpatestingMethod.ONLY_TESTGEN.value, EpatestingMethod.BOTH.value, EpatestingMethod.BOTH_WITHOUT_MUJAVA.value ]: print('GENERATING TESTS') code_dir = self.instrumented_code_dir if "epa" in self.criterion else self.original_code_dir bin_code_dir = self.bin_instrumented_code_dir if "epa" in self.criterion else self.bin_original_code_dir # if exists testsuite in other bug_type, copy it! testsuite_exists = False curr_bug_type = self.bug_type try: lock.acquire() testsuite_exists = cp_testsuite_if_exists_in_other_results( curr_bug_type, self.subdir_testgen, self.generated_test_report_evosuite_dir, self.class_name, self.class_name.split(".")[-1]) except: testsuite_exists = False print("error copying from other bug_type folder to {}".format( self.subdir_testgen)) finally: lock.release() if (not testsuite_exists): run_evosuite( evosuite_jar_path=self.evosuite_jar_path, projectCP=bin_code_dir, class_name=self.class_name, criterion=self.criterion, epa_path=self.epa_path, test_dir=self.generated_test_dir, stopping_condition=self.stopping_condition, search_budget=self.search_budget, report_dir=self.generated_test_report_evosuite_dir) add_fails = False if (self.bug_type.upper() == BugType.ERRPROT.name): # If is run in errprot mode, then always remove asserts and specific exceptions self.assert_type = AssertType.NO_ASSERT_EXCEPTION.name #if("JDBCResultSet" in self.name): #add_fails= True; if self.assert_type.upper() in [ AssertType.NO_ASSERT.name, AssertType.NO_ASSERT_EXCEPTION.name ]: workaround_test( self.generated_test_dir, self.class_name, self.class_name.split(".")[-1] + "_ESTest.java", add_fails, self.assert_type) utils.compile_test_workdir(self.generated_test_dir, code_dir, self.junit_jar, self.evosuite_classes, self.evosuite_runtime_jar_path) if self.method in [ EpatestingMethod.ONLY_METRICS.value, EpatestingMethod.BOTH.value, EpatestingMethod.BOTH_WITHOUT_MUJAVA.value, EpatestingMethod.ONLY_METRICS_WITHOUT_MUJAVA.value ]: print('GENERATING METRICS') if not os.path.exists(self.subdir_testgen): print("not found testgen folder ! '{}'".format( self.subdir_testgen)) exit(1) measure_evosuite(evosuite_jar_path=self.evosuite_jar_path, projectCP=self.bin_instrumented_code_dir, testCP=self.generated_test_dir, class_name=self.class_name, epa_path=self.epa_path, report_dir=self.generated_report_evosuite_dir, criterion="epatransition") measure_evosuite(evosuite_jar_path=self.evosuite_jar_path, projectCP=self.bin_instrumented_code_dir, testCP=self.generated_test_dir, class_name=self.class_name, epa_path=self.epa_path, report_dir=self.generated_report_evosuite_dir, criterion="epaexception") measure_evosuite(evosuite_jar_path=self.evosuite_jar_path, projectCP=self.bin_instrumented_code_dir, testCP=self.generated_test_dir, class_name=self.class_name, epa_path=self.epa_path, report_dir=self.generated_report_evosuite_dir, criterion="epaadjacentedges") # Run Pitest to measure pitest_measure(self.generated_report_pitest_dir, self.class_name, "{}_ESTest".format(self.class_name), self.original_code_dir, self.generated_test_dir) if self.method in [ EpatestingMethod.ONLY_METRICS.value, EpatestingMethod.BOTH.value ]: mujava_measure(self.bug_type, self.name, self.criterion, self.subdir_mutants, self.error_prot_list, self.ignore_mutants_list, self.bin_original_code_dir, self.generated_test_dir, self.class_name, self.junit_jar, self.hamcrest_jar_path, self.generated_report_mujava) # Resume the reports generated all_report_dir = os.path.join(self.subdir_metrics, 'all_reports') command_mkdir_report = 'mkdir {}'.format(all_report_dir) utils.print_command(command_mkdir_report) if not os.path.exists(all_report_dir): os.makedirs(all_report_dir) copy_pitest_csv(self.name, self.generated_report_pitest_dir, all_report_dir) statistics_csv = os.path.join(self.generated_report_evosuite_dir, "statistics.csv") copy_csv(statistics_csv, 'epacoverage_{}'.format(self.name), all_report_dir) statistics_testgen_csv = os.path.join( self.generated_test_report_evosuite_dir, "statistics.csv") copy_csv(statistics_testgen_csv, 'statistics_testgen_{}'.format(self.name), all_report_dir) mujava_csv = os.path.join(self.generated_report_mujava, "mujava_report.csv") if os.path.exists(mujava_csv): copy_csv(mujava_csv, 'mujava_{}'.format(self.name), all_report_dir) else: print("Does not exists mujava file {}".format(mujava_csv)) epacoverage_csv = os.path.join( all_report_dir, "epacoverage_{}.csv".format(self.name)) statistics_testgen_csv = os.path.join( all_report_dir, "statistics_testgen_{}.csv".format(self.name)) jacoco_csv = os.path.join(all_report_dir, "{}_jacoco.csv".format(self.name)) mutations_csv = os.path.join(all_report_dir, "{}_mutations.csv".format(self.name)) resume_csv = os.path.join(self.subdir_metrics, 'resume.csv') criterion = get_alternative_criterion_names(self.criterion) #if self.bug_type.upper() == BugType.ALL.name: pit_mutants_histogram(self.criterion, self.search_budget, self.stopping_condition, mutations_csv, self.generated_test_dir, self.generated_pitest_killer_test, self.runid) make_report_resume(self.class_name, epacoverage_csv, statistics_testgen_csv, jacoco_csv, mutations_csv, resume_csv, self.runid, self.stopping_condition, self.search_budget, criterion, self.bug_type, mujava_csv) if self.method in [EpatestingMethod.ONLY_PIT_MUTANTS_HISTOGRAM.value]: mutations_csv = get_mutation_csv_pit( self.generated_report_pitest_dir) pit_mutants_histogram(self.criterion, self.search_budget, self.stopping_condition, mutations_csv, self.generated_test_dir, self.generated_pitest_killer_test, self.runid)
def copy_csv(file_path, file_name, all_report_dir): dest = os.path.join(all_report_dir, "{}.csv".format(file_name)) command = 'cp {} {}'.format(file_path, dest) utils.print_command(command) shutil.copyfile(file_path, dest)
def generate_pitest_workdir(pitest_dir): # To generate the pitest workdir we need the following hierachy: # pom.xml # src/main/java/ < source code we want to test # src/test/java/ < testsuite command_mkdir_home = "mkdir {}".format(pitest_dir) utils.print_command(command_mkdir_home) if not os.path.exists(pitest_dir): os.makedirs(pitest_dir) pitest_dir_src = os.path.join(pitest_dir, "src") command_mkdir_src = "mkdir {}".format(pitest_dir_src) utils.print_command(command_mkdir_src) if not os.path.exists(pitest_dir_src): os.makedirs(pitest_dir_src) pitest_dir_src_main = os.path.join(pitest_dir, "src", "main") command_mkdir_src_main = "mkdir {}".format(pitest_dir_src_main) utils.print_command(command_mkdir_src_main) if not os.path.exists(pitest_dir_src_main): os.makedirs(pitest_dir_src_main) pitest_dir_src_main_java = os.path.join(pitest_dir, "src", "main", "java") command_mkdir_src_main_java = "mkdir {}".format(pitest_dir_src_main_java) utils.print_command(command_mkdir_src_main_java) if not os.path.exists(pitest_dir_src_main_java): os.makedirs(pitest_dir_src_main_java) pitest_dir_src_test = os.path.join(pitest_dir, "src", "test") command_mkdir_src_test = "mkdir {}".format(pitest_dir_src_test) utils.print_command(command_mkdir_src_test) if not os.path.exists(pitest_dir_src_test): os.makedirs(pitest_dir_src_test) pitest_dir_src_test_java = os.path.join(pitest_dir, "src", "test", "java") command_mkdir_src_test_java = "mkdir {}".format(pitest_dir_src_test_java) utils.print_command(command_mkdir_src_test_java) if not os.path.exists(pitest_dir_src_test_java): os.makedirs(pitest_dir_src_test_java)
if len(set(buttons)) != len(buttons): return [] def get_order(pressed): adjacents = get_available_adjacents(buttons, pressed) candidates = adjacents if pressed else buttons for candidate in candidates: if not pressed or is_next(pressed[-1], candidate): order = get_order(pressed + [candidate]) if len(order) == len(buttons): return order return pressed return get_order([]) def get_positions(order, buttons): return map(lambda button: order.index(button) + 1, buttons) def get_sin_list(buttons): return ' '.join(map(lambda n: SINS[n].colored_name(), list(buttons))) if __name__ == "__main__": print_info('Input buttons order going clockwise starting from the top left.') print_info('\n'.join(map(lambda sin: f'{sin[0]}: {sin[1]!r}', SINS.items()))) buttons = input('Current buttons order: ').replace(' ', '') print_info(get_sin_list(buttons)) solution = solve(buttons) if solution: print_command(f"press {' '.join(list(map(str, get_positions(buttons, solution))))}") print(get_sin_list(solution)) else: print_info('No solution. Please check input.')
def create_project(project_name, default, helloworld, api, spa): """ This function is responsible for interacting user with file creation. Args: project_name (string): This is the project name that will be used for project creation. api (bool): This flag says if project is going to have api-like boilerplate structure. spa (bool): This flag says if project is going to have spa-like boilerplate structure. Raises: FileExistsError: If project_name param has the same value as some of the directories in the current directory. """ # getting arguments and options from the locals() function options = locals() # project_name is removed since we want to browse through options and project_name isn't necessary options.pop('project_name') # if none of the options was selected, fall back to default if [i for i in options.values()].count(True) == 0: options['default'] = True # seeing if there are more than 2 options selected elif [i for i in options.values()].count(True) > 1: error_exit("Please make sure only 1 option is selected and try again.") # seeing if project_name matches any of directories in the current directory try: create_folder(project_name) except FileExistsError: error_exit( 'That directory already exists. Please check your project name and try again.' ) # printing when project creation is starting click.echo(NEWLINE + 'Creating a new Flask app in ' + colored(f'~/{project_name}', 'green') + '.') click.echo(NEWLINE) # create venv if helloworld option is not selected if not helloworld: create_venv(f'./{project_name}/venv/') # deciding which boilerplate to choose and creating it based on argument choice base_dir = os.path.dirname(__file__) # iterating over names and values in options dictionary for name, value in options.items(): if value: choice = os.path.join(base_dir, name) # copy the boilerplate filetree to the project folder try: copy_filetree(choice, f"./{project_name}/") except Exception as e: error_exit(e) # output hell starts here click.echo(f'Success! Created app {project_name} in {os.getcwd()}' + f'/{project_name}') click.echo('Inside that directory you can run several commands:') click.echo(NEWLINE) # print commands and descriptions print_command('python run.py', 'Starts the server, default config is set to development.') if not helloworld: print_command('export secret_key=STRING', 'Sets the secret key for your app.') print_command( 'export PRODUCTION=True', 'Sets production config for your app. Setting it to False will set the development config.' ) print_command( 'source venv/bin/activate (unix) \n\t./venv/Scripts/activate (windows)', 'Activate the virtual enviroment for the app.') print_command( 'pip install -r requirements.txt', 'Install the packages listed in requirements.txt into the venv.') click.echo('We suggest that you start by typing:') click.echo(colored('\tcd ', 'cyan') + colored(project_name, 'white')) click.echo( colored( '\tsource venv/bin/activate' if not system() == 'Windows' else '\t./venv/Scripts/activate', 'cyan')) click.echo( colored('\tpip install -r ', 'cyan') + colored('requirements.txt', 'white')) click.echo(colored('\tpython run.py', 'cyan')) else: click.echo('We suggest that you start by typing:') click.echo(colored('\tcd ', 'cyan') + colored(project_name, 'white')) click.echo(colored('\tpip install flask ', 'cyan')) click.echo(colored('\tpython app.py')) click.echo(NEWLINE + 'Happy hacking!')
funni -= len(get_divisors(n, UNFUNNY)) # If the number is even subtract one funni point, otherwise add 1 funni point. if n % 2 == 0: funni -= 1 else: funni += 1 # If the number is prime, add 2 funni points. if is_prime(n): funni += 2 # If the number is a perfect square, subtract 2 funni points. root = sqrt(n) if root == int(root): funni -= 2 # If the number is the square of a prime, subtract another 2 funni points. if is_prime(root): funni -= 2 print_info(funni) return funni > 0 if __name__ == "__main__": try: print_info('Press Ctrl+C to cancel') for i in range(5): if is_funny(input_number('Number: ')): print_command('funny') else: print_command('unfunny') except KeyboardInterrupt: pass
#!/usr/bin/python3 # -*- coding: utf-8 -*- # https://ktane.timwi.de/HTML/Prime%20Checker.html from math_utils import is_prime from utils import input_number, print_info, print_command if __name__ == "__main__": try: print_info('Press Ctrl+C to cancel') while True: n = input_number('Number: ') if is_prime(n): print_command('prime') else: print_command('not prime') except KeyboardInterrupt: pass