def to_string(caseType: int) -> str: """ Converts the casetype enum int into a readable string """ if caseType == CaseType.SAMPLE: return Definitions.get_value(CaseType.SAMPLE_STRING_KEY) elif caseType == CaseType.CORNER_CASE: return Definitions.get_value(CaseType.CORNER_STRING_KEY) else: return Definitions.get_value(CaseType.GENERATED_STRING_KEY)
def from_string(string: str) -> int: """ Converts the CaseType strings defined in the definitions file to their respective enum int values. If invalid string, assumed generated :param string: The string to convert to enum """ if string == Definitions.get_value(CaseType.SAMPLE_STRING_KEY): return CaseType.SAMPLE elif string == Definitions.get_value(CaseType.CORNER_STRING_KEY): return CaseType.CORNER_CASE else: return CaseType.GENERATED
def get_all_cases(problemNumber=None): """ Resolves the cases directory from the definitions file and delegates to _get_all_cases :return: {problemNumber: [Case]} """ return _get_all_cases(fileops.join_path(PathMapper._rootPath, Definitions.get_value('test_directory')), problemNumber=problemNumber)
def test_get_value_unit(self, mocked_load_definitions): """ Ensure Definitions.get_value functions properly as a unit """ # Before doing anything, definitionsDict should be None and load called def setDefDict(): Definitions._definitionsDict = {} mocked_load_definitions.side_effect = setDefDict self.assertEqual(Definitions.get_value('invalidKey'), None) mocked_load_definitions.assert_called_with() # With a good definitions dict, ensure a key inside the dict returns val mocked_load_definitions.side_effect = None Definitions._definitionsDict = { 'key1' : 'val1', 'key2' : 'val2' } self.assertEqual(Definitions.get_value('key1'), 'val1') self.assertEqual(Definitions.get_value('nonkey'), None) Definitions._definitionsDict = None
def package_into_path(path: str, layoutDict: dict): """ Follows the users provided configuration file to package all cases into the provided path. Delegates most functionality to other functions. Arguments: path: str - The path to package into layoutDict: dict - The dict provided by the user's configuration """ # Look through all cases... for problemNumber, caseList in case.get_all_cases().items(): # Make the directories for the problem numbers problemDirName = Definitions.get_value('solution_naming').format( **dict(problem=problemNumber)) problemPath = fileops.join_path(path, problemDirName) fileops.make(problemPath, FileType.DIRECTORY) # Go through each type in the config file and package it for packageTypeName, packageType in layoutDict[TYPES_KEY].items(): package_type(problemPath, caseList, packageType, _get_compression_from_layout_dict(layoutDict), packageTypeName)
def operate(args): """ Takes the passed in args and delegates to proper functionality. This is set as the executable function when the `writers assign` subparser is used. Arguments: args: Namespace - The arguments passed via CLI """ # If the user specified a problem list, use that as the list of problems. problemParser = NumberParse() if not args.problems is None: specifiedProblems = problemParser.str_list_to_uniq_range(args.problems) else: specifiedProblems = problemParser.str_list_to_uniq_range(['1+']) specifiedLanguages = [] if not args.language is None: for languageName in args.language: loadedLanguage = Languages.get_language_by_name(languageName) if loadedLanguage is None: raise PyCException('Error: {} is an invalid language'.format(languageName)) specifiedLanguages.append(loadedLanguage) else: specifiedLanguages = [Languages.get_language_by_name(name) for name in Languages.get_all_language_names()] specifiedWriters = [] if not args.full and not args.writer_names is None and len(args.writer_names) > 0: for writerName in args.writer_names: loadedWriter = Writer.load_from_folder(writerName) if loadedWriter is None: raise PyCException('Error: {} is an invalid writer'.format(writerName)) specifiedWriters.append(loadedWriter) else: specifiedWriters = Writers.get_all_writers() allocator = AssignmentAllocator(specifiedProblems, specifiedLanguages, specifiedWriters, fromScratch=args.full) allocator.do_assignment(Definitions.get_value('complete_threshold'), overflow=args.overallocate)
def validate_defined_case_dir(): testDir = Definitions.get_value('test_directory') validate_casefiles(fileops.get_files_in_dir(testDir))
def str_to_list_range(self, string): lowerBound = 1 upperBound = Definitions.get_value('problem_count') return self.str_to_list_range_with_bounds(string, upperBound, lowerBound)