""" Program for updating dataset with tokenized solutions of given problems. - Tokenized representations of all solutions of each problem are placed in a single file. - The files with tokenized solutions of problems are added into existing directory. - Each tokenized source code file is represented in the following form: :'\n' - The program can select for tokenisation solutions having the specified status. If the specified status is 'All', all problem solutions are tokenized. - The program selects problems having not fewer tokenizable solutions than the specified parameter. - The program has parameter specifying the limit of the number problems to tokenize. If that number is None all existing problems satisfying to the selection criteria are tokenized. """ import sys import os from os import path import argparse import json main_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) sys.path.extend([f"{main_dir}/Dataset"]) from DsUtilities import getProblemSet from DSTokenizer import BaseDsTokenizer def makeProblemList(ds, source): """ Analyze source code dataset and write down list of problems to tokenized dataset Parameters: - ds -- directory of tokenized datset to be constructed - source -- directory with source code files of problem solutions """ _problems = os.listdir(source) if not _problems: sys.exit(f"Directory {source} of source code dataset is empty") problem_dict = {} volume_hist = {} print(f"Analyzing source code dataset with {len(_problems)} problems") _n_problems = 0 _n_all_solutions = 0 for _p in _problems: _sol_dir = source + '/' + _p _solutions = os.listdir(_sol_dir) if not _solutions: print(f"Directory {_sol_dir} has no source code files") continue _n_problems += 1 _n_solutions = len(_solutions) _n_all_solutions += _n_solutions problem_dict[_p] = _n_solutions try: volume_hist[_n_solutions] += 1 except KeyError: volume_hist[_n_solutions] = 1 out_fn = ds + '/' + "problems.json" with open(out_fn, 'w') as out_json: json.dump(problem_dict, out_json) print(f"Imported {_n_problems} problems with {_n_all_solutions} solutions") #------------- End of function makeProblemList ----------- class ImportDsTokenizer(BaseDsTokenizer): """ Class for tokenizing solutions of all problems of imported datset, which is different from CodeNet and writing down tokenized solution code to dataset """ def __init__(self, ds, data, lang, verbose, no_macro, update = True, token_set = "17classes", debug = False): """ Initialize tokenizer object Parameters: - ds -- Directory to write down tokenized solutions - data -- Directory with source code of problem solutions - lang -- language of the solution code - verbose -- flag to print tokenizer warning - no_macro -- flag not to tokenize macro definitions - update -- flag to update tokenized problems in constructed dataset - token_set -- name of set of tokens to use: - either "17classes" for combined tokens into 17 classes. - name of sets language operators and keywords for detailed operational mode - debug -- flag to debug tokenization """ super(ImportDsTokenizer, self).__init__(ds, data, lang, verbose, no_macro, update =update, token_set = token_set, debug = debug) def tokenizeProblem(self, sol_dir, out_fn): """ Tokenize solution files of given problem and combine results in a single file, collect statistics about tokenized problems and their solutions Tokenization of each file is represented in the following format: :'\n' Parameters: - sol_dir -- directory with solutions to tokenize - out_fn -- Name of output file to write tokenized code Returns: - number of files tokenized Updates: - self.sol_len_distr distribution of solution lengths """ _not_found = [] _failed = [] _without_tokens = [] _n_files_analyzed = 0 _n_files_tokenized = 0 _solutions = os.listdir(sol_dir) with open(out_fn, 'w') as _fout: for _s in _solutions: _n_files_analyzed += 1 _solution = _s.rpartition('.')[0] _file2tokenize = f"{sol_dir}/{_s}" if not os.path.exists(_file2tokenize): _not_found.append(_file2tokenize) continue _n_files_tokenized += self.tokenizeFile( _file2tokenize, _solution, _fout, _failed, _without_tokens) self.not_found += _not_found self.failed_tokenized += _failed self.without_tokens += _without_tokens print(f"Problem {sol_dir} was tokenized into {out_fn}") print(f" Number of files analyzed: {_n_files_analyzed}") print(f" Number of files tokenized: {_n_files_tokenized}") if _not_found: print(f" Number of files not found: {len(_not_found)}") if _failed: print(f" Number of files failed to tokenize: {len(_failed)}") if _without_tokens: print(f" Number of files without intertesting tokens: {len(_without_tokens)}") return _n_files_tokenized def tokenizeAllProblems(self, problem_list): """ Tokenize all problems Parameters: - problem_list -- problems to tokenize their solutions """ #Dictionary for distribution of solution length self.sol_len_distr = {} #Dictionary of tokenized problems: #Key: number of solutions. #Value list of problems self.tokenized_problems = {} #List of source code files not found self.not_found = [] #List of source code files failed to tokenize self.failed_tokenized = [] #List of source files having no interesting tokens self.without_tokens = [] self.n_all_tokenized_sol = 0 self.valid_problems = {} for _i, _p_data in enumerate(problem_list): _problem, _n_solutions = _p_data _output_fn = f"{self.ds}/{_problem}.tkn" if not self.update and os.path.exists(_output_fn): print(f"#{_i + 1}: Problem {_problem} is skipped. " + "The tokenized dataset already has it") continue print(f"#{_i + 1}: " + f"Tokenize problem {_problem} with {_n_solutions} solutions") _solution_dir = f"{self.data}/{_problem}" if not os.path.exists(_solution_dir): sys.exit(f"Directory {_solution_dir} with source code files is not found") _n_tokenized_sols = self.tokenizeProblem( _solution_dir, _output_fn) if _n_tokenized_sols: self.n_all_tokenized_sol += _n_tokenized_sols self.tokenized_problems[_problem] = _n_tokenized_sols try: self.valid_problems[_n_tokenized_sols].append(_problem) except KeyError: self.valid_problems[_n_tokenized_sols] = [_problem] else: os.system(f"rm {_output_fn}") print(f"Problem {_problem} with solutions in {_solution_dir} " + "has no tokenized solutions") self.tok_debugger.endDebug() self.printReport() self.writeInfo() #------------- End of class ImportDsTokenizer ----------------------------- def main(args): """ Main function of program for making dataset with tokenized solutions of given problem Parameters: - args -- Parsed command line arguments as object returned by ArgumentParser """ if not os.path.exists(args.ds): os.makedirs(args.ds) if not os.path.exists(args.source): sys.exit(f"Directory {args.source} of source code dataset is not found") makeProblemList(args.ds, args.source) _problem_list = getProblemSet(args.ds, args.size, args.n_problems) if not _problem_list: sys.exit(f"No problems have required number {args.size} of solutions") tokenizer = ImportDsTokenizer(args.ds, args.source, args.language, args.verbose, args.no_macro, args.update, args.tok_set, args.debug) tokenizer.tokenizeAllProblems(_problem_list) #------------- End of function main ----------------------------- ################################################################################ # Command line arguments are described below ################################################################################ if __name__ == '__main__': print("\nTOKENIZING IMPORTED DATASET") #Command-line arguments parser = argparse.ArgumentParser( description = "Make tokenized dataset from imported data") parser.add_argument("ds", type=str, help="Directory to construct tokenized dataset") parser.add_argument("--source", type=str, default="/Volume1/AI4CODE/POJ-104/raw/ProgramData", help="Path to source code dataset") parser.add_argument("--language", type=str, default="C++", choices=["C", "C++", "Java", "python"], help="programming language: either C, C++, Java or python") parser.add_argument("--tok_set", type=str, default="CPP56X", help=("name of token set: " + "17classes, CPP52, CPP54, CPP56, CPP56X, Java, etc.")) parser.add_argument('--size', default=1, type=int, help='number of files with solutions of source code') parser.add_argument('--n_problems', default=None, type=int, help='number of problems to tokenize solutions') parser.add_argument('--update', default=False, action='store_true', help="rewrite existing files with tokenized solutions") parser.add_argument('--verbose', default=False, action='store_true', help="report tokenization warnings") parser.add_argument('--no_macro', default=False, action='store_true', help="do not tokenize macro definitions") parser.add_argument('--debug', default=False, action='store_true', help="run in debug mode") args = parser.parse_args() print("Parameter settings used:") for k,v in sorted(vars(args).items()): print("{}: {}".format(k,v)) main(args)