def submitToMoss(): try: # Get form information from site request_json = request.get_json() moss_query = query_db('select MOSS_ID from Users where USER_NAME = ?', [session['name']], one=True) moss_id = moss_query[0] moss_code_type = request_json['code_type'] if moss_code_type not in mosspy.Moss(0).getLanguages(): moss_code_type = 'python' # Initialize moss connection m = mosspy.Moss(moss_id, moss_code_type) (submission_dir, course_and_assignment_list) = pull_submission_requests( request_json['submissions'], m) if 'base_files' in request_json: add_base_files_to_moss(request_json, m) # Submit moss report and delete staging files moss_report_url = m.send() shutil.rmtree(submission_dir) add_report_to_db(moss_id, moss_report_url, course_and_assignment_list) return moss_report_url except: logger.error('{} An error has occured:\n{}'.format( ts, sys.exc_info()[0])) raise
def get_moss_results(userid, basefile_name, testfiles_path ,language, report_path): real_language = None if language == 'html': real_language = 'javascript' else: real_language = language moss_obj = mosspy.Moss(userid, real_language) moss_obj.addBaseFile(basefile_name) language_extensions = { "javascript" : "js", "python" : "py", "c++" : "cpp", "c" : "c", "java" : "java", 'html' : 'html' } moss_obj.addFilesByWildcard(testfiles_path+"/*."+language_extensions[language]) url = moss_obj.send() print ("Report Url: " + url) mosspy.download_report(url, report_path+"/report", connections = 8)
def run_moss(self): current = os.getcwd() self.create_moss_folder() userid = 360162800 m = mosspy.Moss(userid, "python") #cpp moss if self.cpp_exist: os.chdir(self.mossfolderpath + r'\mosscpp') for stu in os.listdir( os.getcwd()): #moss id of courses for each student stu = os.path.abspath(stu) for best_sub in os.listdir(stu): for cpps in os.listdir(best_sub): stusubs = stu + fr'{best_sub}\cpp\{cpps}' m.addFile(stusubs) url = m.send() m.saveWebPage(url, "cppreport.html") # Save report file #python moss if self.python_exist: os.chdir(self.mossfolderpath + r'\mosspython') for stu in os.listdir( os.getcwd()): #moss id of courses for each student stu = os.path.abspath(stu) for best_sub in os.listdir(stu): for cpps in os.listdir(best_sub): stusubs = stu + fr'{best_sub}\cpp\{cpps}' m.addFile(stusubs) url = m.send() m.saveWebPage(url, "pythonreport.html") # Save report file os.chdir(current)
def send_moss_dir_mode(submission, basefile, language): userid = 78325144 root = os.getcwd() moss = mosspy.Moss(userid, language) moss.setDirectoryMode(True) os.chdir(basefile) for base in os.listdir(): path = os.path.join(os.getcwd(), base) if os.path.isfile(base): moss.addBaseFile(path) os.chdir(root) os.chdir(submission) submissions = os.getcwd() students = os.listdir() for student in students: student_submission = os.path.join(submissions, student) os.chdir(student_submission) for s_file in os.listdir(): if os.path.isfile(s_file): student_file = os.path.join(student_submission, s_file) moss.addFile(student_file) os.chdir(submissions) url = moss.send() print() moss.saveWebPage(url, "report.html")
def main(): """ This allows us to send all of the diff bug reports that we generated into MOSS to compare them. :return: """ with open(KEYS_PATH, "r") as stream: moss_key = yaml.load(stream, Loader=yaml.BaseLoader)['moss_key'] # The MOSS instance m = mosspy.Moss(moss_key, "C") # This means that only files from separate directories will be compared to eachother m.setDirectoryMode(1) # The directories files will be taken from compare_list = ['Arduino', 'ardupilot', 'elasticsearch'] # The number of files sent from each directory n = 10 # Add's files to the MOSS request that will be send for name in compare_list: add_n_files_from_folder(m, name, n) print('Sending files to MOSS') url = m.send() # Submission Report URL print("Report Url: " + url) m.saveWebPage(url, "../submission/report.html") mosspy.download_report(url, "../submission/report/", connections=8)
def contest_duplicate(contest, QuestionList): folder = 'C:/Users/lifeiteng/projects/visualizer/getRank/Contest submission/' + str( contest) + '/' # coding_languages = ['python3', 'cpp', 'java'] coding_languages = ['python3'] # coding_languages = ['csharp','golang','javascript','python','rust','scala'] # QuestionList = [1549,1550] userid = 65431 for coding_language in coding_languages: folderPath = folder + coding_language if not os.path.exists(folderPath): continue for question in QuestionList: languageFolder = folder + coding_language + '/' + str(question) files = os.listdir(languageFolder) numberOfFiles = len(files) m = mosspy.Moss(userid, coding_language) print('Number of %s files = ... %d ' % (coding_language, numberOfFiles)) for i in range(numberOfFiles): try: file1name = files[i] file1Location = languageFolder + '/' + file1name m.addFile(file1Location) except Exception as err: print(err) pass print("now sending to moss...") url = m.send() print("Report Url: " + url)
def hello1(): data = json.loads(request.data) lang = data["lang"] print(lang) extensions = { "py": "py", "cc": "cpp", "c": "c", "js": "js", "java": "java", "haskell": "haskell", "fortran": "fortran", "csharp": "c#", "vb": "vb" } moss = mosspy.Moss(data["userId"], lang) fA_name = "client/submission/a." + extensions[lang] fA = open(fA_name, "w") fA.write(data["fileA"]) fA.close() fB_name = "client/submission/b." + extensions[lang] fB = open(fB_name, "w") fB.write(data["fileB"]) fB.close() moss.addFile(fA_name) moss.addFile(fB_name) url = moss.send() print(url) #userid that work :12 ,123, 315118721 ,2, 3 res = make_response(jsonify({"url": url}), 200) return res
def __init__(self, lang: str, user_id: str): self.__user_id = user_id languages = mosspy.Moss.languages if lang not in languages: raise ValueError(f"{lang} is not a supported language {languages}") self.lang = lang self.__moss = mosspy.Moss(self.__user_id, self.lang)
def get_report_task(user, problem_id): # select all ac code submissions = Submission.filter( user=user, offset=0, count=-1, status=0, problem=problem_id, ) last_cc_submission = {} last_python_submission = {} for submission in submissions: s = Submission(submission.id) if s.language in [0, 1] and s.user.username not in last_cc_submission: last_cc_submission[submission.user.username] = s.main_code_path elif s.language in [2] \ and s.user.username not in last_python_submission: last_python_submission[submission.user.username] = s.main_code_path moss_userid = 97089070 # check for c or cpp code m1 = mosspy.Moss(moss_userid, "cc") for user, code_path in last_cc_submission.items(): logging.info(f'send {user} {code_path}') m1.addFile(code_path) cpp_report_url = m1.send() # check for python code m2 = mosspy.Moss(moss_userid, "python") for user, code_path in last_python_submission.items(): logging.info(f'send {user} {code_path}') m2.addFile(code_path) python_report_url = m2.send() # insert report url into DB problem = Problem(problem_id) problem.obj.update( cpp_report_url=cpp_report_url, python_report_url=python_report_url, )
def sendToMoss(): for p in problems: for l in config['languages']: moss = mosspy.Moss(config['userid'], l) moss.addFilesByWildcard('./{}/*.{}'.format(p['name'], getLangExtension(l))) url = moss.send() print "Moss url: ", url print p['name'], l # Seems buggy from mosspy project mosspy.download_report(url, 'Plagiarism/{}/{}/'.format(p['name'], l), connections=8)
def get_binary_score(self, original_file, refactored_file): m = mosspy.Moss(self.userid, "python") m.addFile(original_file) m.addFile(refactored_file) url = m.send() logging.debug('Report URL: {}'.format(url)) return self.parse_response(url)
def plagcheck(): userid = 389750029 m = mosspy.Moss(userid, "python") # Submission Files m.addFilesByWildcard("submission/*.py") url = m.send() # Submission Report URL print("Report Url: " + url) # Save report file m.saveWebPage(url, "report.html") # Download whole report locally including code diff links mosspy.download_report(url, "submission/report/", connections=8) webbrowser.open('report.html', new=2)
def init_moss(self, language): language_list = [ "c", "cc", "java", "ml", "pascal", "ada", "lisp", "scheme", "haskell", "fortran", "ascii", "vhdl", "perl", "matlab", "python", "mips", "prolog", "spice", "vb", "csharp", "modula2", "a8086", "javascript", "plsql", "verilog" ] for lang in language_list: if lang == language.lower(): self.moss_obj = mosspy.Moss(self.userid, language) return raise ValueError("Language not valid choice of language from MOSS.")
def generate_moss_report(force_refresh): if config.MOSS_REPORT_FOLDER.is_dir(): print('Moss report already complete', end='') if force_refresh: print(' - Forcing refresh anyway') shutil.rmtree(config.MOSS_REPORT_FOLDER) else: print() return print('Generating Moss report') moss = mosspy.Moss(config.MOSS_USER_ID, 'python') # Create folder for Moss report config.MOSS_REPORT_FOLDER.mkdir() concatenated_files_folder = config.MOSS_REPORT_FOLDER / 'concatenated_files' concatenated_files_folder.mkdir() print('\tConcatenating source files') for unzipped_folder in config.UNZIPPED_FILES_FOLDER.iterdir(): concatenated_file_path = concatenated_files_folder / ( unzipped_folder.name + '.txt') # Concatenate source files into a single file with open(concatenated_file_path, 'w') as concatenated_file: patterns_to_concatenate = ['*.cpp', '*.h', '*.inl'] source_file_paths_to_concatenate = [] for pattern in patterns_to_concatenate: source_file_paths_to_concatenate.extend( unzipped_folder.glob(pattern)) for source_file_path in source_file_paths_to_concatenate: with open(source_file_path, errors='replace') as source_file: concatenated_file.write(source_file.read()) # Only upload non-empty files if concatenated_file_path.stat().st_size > 0: moss.addFile(str(concatenated_file_path)) # Upload files print('\tUploading files to Moss') report_url = moss.send() # Save generated report print('\tDownloading Moss report') mosspy.download_report(report_url, config.MOSS_REPORT_FOLDER / 'report', connections=8)
def duplicate_check(request, homework_id): if request.session.get("a_login", None): if homework_id == "!": homeworks = models.Homework.objects.all() return render(request, "homework/duplicate.html", locals()) else: homework_id = int(homework_id) homework = get_object_or_404(models.Homework, id=homework_id) duplicate = models.DuplicateCheck.objects.filter(homework=homework) now = datetime.datetime.now() if len(duplicate) == 0: duplicate = models.DuplicateCheck.objects.create( homework=homework, time=now) else: duplicate = duplicate[0] submits_number = len(homework.submits.all()) effective = now < duplicate.time + datetime.timedelta( settings.MOSS_DAYS) if submits_number == duplicate.submit_number and effective: if re.match(r'^http?:/{2}\w.+$', duplicate.result): return redirect(duplicate.result) else: return HttpResponse(u"此次作业没有py文件可以查重") else: userid = settings.MOSS_ID m = mosspy.Moss(userid, "python") media_path = settings.MEDIA_ROOT homework_path = os.path.join(media_path, homework.name) submit_dirs = [ p for p in os.listdir(homework_path) if os.path.isdir(os.path.join(homework_path, p)) ] if os.path.exists( os.path.join(media_path, "{}.py".format(homework.name))): m.addBaseFile( os.path.join(media_path, "{}.py".format(homework.name))) for s in submit_dirs: m.addFilesByWildcard(os.path.join(homework_path, s, "*.py")) url = m.send() duplicate.result = url duplicate.time = datetime.datetime.now() duplicate.submit_number = submits_number duplicate.save() if re.match(r'^http?:/{2}\w.+$', url): return redirect(url) else: return HttpResponse(u"此次作业没有py文件可以查重")
def run_mosspy(wd, project_name, m, uid): mpy = mosspy.Moss(uid, "python") mpy.setIgnoreLimit(m) repos_dir = os.path.join(wd, 'repos', project_name) for starter_src in os.listdir(os.path.join(repos_dir, 'starter')): mpy.addBaseFile(os.path.join(repos_dir, 'starter', starter_src)) mpy.addFilesByWildcard(os.path.join(repos_dir, "students", "*", "*.java")) report_url = mpy.send() print("Report url: " + report_url) return report_url
def submit_moss(location="/tmp/homework/"): import mosspy userid = 273660752 m = mosspy.Moss(userid, "python") m.setDirectoryMode(1) m.addFilesByWildcard(os.path.join(location, "*/*.py")) m.addFilesByWildcard(os.path.join(location, "*/*/*.py")) url = m.send() # Submission Report URL print ("Report Url: " + url) return m, url
def moss_check(submissions, assignment, request): moss = mosspy.Moss( settings.MOSS_USER_ID, assignment.get_language_display(), ) moss.setDirectoryMode(1) with TemporaryDirectory() as _tmp: tmp = Path(_tmp) for submission in submissions: buff = BytesIO() try: submission.download(buff) except MissingFile: msg = f"File missing for {submission!r}" messages.error(request, msg) log.warning(msg) submission_archive = ZipFile(buff) submission_archive.extractall( tmp / f"{submission.user.username}", ) read_files = glob.glob( str( tmp / ( f"{submission.user.username}" f"/**/*.{submission.assignment.language}" ) ), recursive=True, ) for f in read_files: user_dir = f[len(str(tmp)) :] new_filename = ( user_dir.split("/")[1] + f"/{submission.user.username}_" + user_dir.split("/")[-1] ) moss.addFile(f, new_filename) url = moss.send() return url
def moss(self): m = mosspy.Moss(settings.MOSS_USERID, "c") extract_dir = self.extract_dirname() if not os.path.exists(extract_dir): raise self.AssignmentException( 'It seems like the zip file for assignment %s has not been extracted' % self.name) m.addFilesByWildcard('%s/*.c' % extract_dir) url = m.send() logger.info('Report URL: %s ' % url) # Save report file report_dir = self.report_dirname() if not os.path.exists(report_dir): os.makedirs('%s/%s' % (report_dir, 'report/')) m.saveWebPage(url, "%s/report.html" % report_dir)
def selection(): try: user = query_db('select * from Users where USER_NAME = ?', [session['name']], one=True) logger.info('{} Found user {}'.format(ts, user)) return render_template('selection.jade', selectionjs=True, user_name=user[1], moss_id=user[0], moss_languages=sorted( mosspy.Moss(0).getLanguages()), extensions=upload_allowed_extensions) except: logger.error('{} An error has occured:\n{}'.format( ts, sys.exc_info()[0])) raise
def run_mosspy(base_files, output_folder, ignore_limit): plagiarism_output_folder = os.path.join(output_folder, 'plagiarism') if not os.path.exists(plagiarism_output_folder): os.makedirs(plagiarism_output_folder) reports = [] # Run for each file separately --> better accuracy for file in base_files: filename = os.path.basename(file) m = mosspy.Moss(MOSSPY_USERID, 'java') m.setIgnoreLimit(int(ignore_limit)) m.addBaseFile(file) for f in get_files([file], output_folder): m.addFile(f) print(f"Sending files for {filename}") report_url = m.send() # Submission Report URL if report_url.startswith('Error:'): print(f"Error for {filename}: {report_url}") continue else: print(f"Report Url for {filename}: {report_url}") print(f"Downloading reports for {filename}... ", end='') # report_file = os.path.join(output_folder, 'report.html') # m.saveWebPage(report_url, report_file) report_folder = os.path.join( plagiarism_output_folder, f"reports_{filename}/") mosspy.download_report(report_url, report_folder, connections=8, log_level=logging.WARNING) print('Done') reports.append({ 'file': filename, 'report': report_folder }) return reports
def check(self): """ :return: """ if self.id == None: self.get_code() os.makedirs(self.id + "/ans") for i in self.languages: for j in self.problem_name: m = mosspy.Moss(self.userid, self.to_language[i]) _path = self.id + '/' + j m.addFilesByWildcard(_path + '/*.' + self.hash[i]) try: url = m.send() self.urls.append(url) print(url) m.saveWebPage(url, self.id + "/ans/" + i + j + ".html") except BaseException as FileExistsError: pass
def check_similarity(mongo, hw_id): #create a new directory to store all the files current_directory = os.getcwd() temp_dir = uuid.uuid4().hex os.makedirs(temp_dir) os.chdir(temp_dir) #populate files with student names and subbmited code # client = MongoClient() ans = mongo.db.submissions.find({'assignment_id': int(hw_id)}) for a in ans: with open(a['Student'] + ".py", 'w+') as f: f.write(a['code']) #send a MOSS querry and delete the folder with the files afterwards m = mosspy.Moss(MOSS_USERID, "python") m.addFilesByWildcard("*.py") url = m.send() os.chdir(current_directory) shutil.rmtree(temp_dir, True) return url
def run_check(self, language, directories): # Load moss user id from env variables moss_user_id = os.getenv('MOSS_USER_ID') # Initialize Moss moss = mosspy.Moss(moss_user_id, language) if directories: moss.setDirectoryMode(1) file_exts = get_file_extensions(language) # Move files from subdirectories to parent directories and relevant language files for directory in directories: extract_files_from_dir(directory, self.paths) for ext in file_exts: moss.addFilesByWildcard(directory + '/*.{}'.format(ext)) else: return # Run Check url = moss.send() return url
def moss_download(unzip_dir, result_buffer_dir, config): language_list = ['cc', 'java', 'python'] buffer_dir_list = ['c++', 'java', 'python'] prefix_list = ['cpp', 'java', 'py'] for language, dir_lan, prefix in zip(language_list, buffer_dir_list, prefix_list): if language not in config.language: continue for problem in os.listdir(unzip_dir): submission_dir = os.path.join(unzip_dir, problem) buffer_dir = os.path.join(result_buffer_dir, dir_lan, problem) wildcard = os.path.join(submission_dir, f"*.{prefix}") if len(list(glob.glob(wildcard))) <= 1: continue m = mosspy.Moss(config.moss_userid, language) m.setIgnoreLimit(config.maximal_match) m.setNumberOfMatchingFiles(config.report_number) if config.base_dir is not None: moss_base_file = os.path.join(config.base_dir, f"{problem}.cpp") if os.path.exists(moss_base_file): m.addBaseFile(moss_base_file, "base") if config.add_dir is not None: moss_add_dir = os.path.join(config.add_dir, problem) moss_add_wildcard = os.path.join(moss_add_dir, "*") if os.path.exists(moss_add_dir) and len( glob.glob(moss_add_wildcard)) > 0: m.addFilesByWildcard(moss_add_wildcard) wildcard = os.path.join(submission_dir, f"*.{prefix}") m.addFilesByWildcard(wildcard) url = m.send() print("Report Url: " + url) if not url.startswith("http"): continue mosspy.download_report(url, buffer_dir + os.sep, 8, logging.INFO)
def make_moss_folder(assignment_id: int, db: session = Depends(session)): assignment = db.query(models.Assignment).get(assignment_id) files = db.query(models.SubmissionFile)\ .join(models.Submission, models.Assignment)\ .filter(models.SubmissionFile.filename == "LList.cpp", models.Assignment.id == assignment_id)\ .all() m = mosspy.Moss(config.MOSS_USERNAME, 'cc') moss_folder = os.path.join(assignment.path, '__MOSS__') if os.path.exists(moss_folder): shutil.rmtree(moss_folder) os.mkdir(moss_folder) [shutil.copy( os.path.join(config.UPLOAD_DIR, f.path), os.path.join(moss_folder, f'{f.submission.student.name.replace(" ", "")}_{f.filename}')) for f in files] m.addFilesByWildcard(f'{moss_folder}/*.cpp') url = m.send() assignment.description = url assignment.save(db)
def main(args): print('\n\n' + 'Submitting files to Moss'.center(80, '=')) args = parser.parse_args(args) print('Args:\n' + ''.join(f'\t{k}: {v}\n' for k, v in vars(args).items())) github_utils.verify_token(args.token) moss = mosspy.Moss(args.user_id, language=args.l) moss.setIgnoreLimit(args.m) moss.setCommentString(args.c) moss.setNumberOfMatchingFiles(args.n) moss.setExperimentalServer(opt=int(args.x)) moss.setDirectoryMode(mode=int(args.d)) repositories = github_utils.get_students_repositories( token=args.token, org_name=args.org_name, repo_filter=args.repo_filter) if args.base_files_repo_fullname != '': repo = github_utils.get_repo(fullname=args.base_files_repo_fullname, token=args.token) add_base_files(moss=moss, base_files=args.paths, repo=repo) print(f'Org: {args.org_name}') add_paths(moss=moss, paths=args.paths, repositories=repositories) report_url = moss.send() print(f'Report url: {report_url}') save_report(moss=moss, report_name=args.report_name, report_url=report_url)
def plagiarism_view(request, class_pk, assignment_pk): class_object = get_object_or_404(models.Class, pk=class_pk) if request.user not in class_object.instructors.all(): raise Http404('No Class matches the given query.') assignment_object = get_object_or_404(models.Assignment, pk=assignment_pk) if not assignment_object in class_object.assignments.all(): raise Http404('No Assignment matches the given query.') if request.method == 'POST': form = forms.PlagiarismForm(request.POST) if form.is_valid(): language = form.cleaned_data['language_field'] m = mosspy.Moss(settings.MOSS_ID, language) submissions = models.Submission.objects.filter( assignment=assignment_object).order_by( 'submitter', '-timestamp').distinct('submitter') dir = tempfile.TemporaryDirectory() for submission in submissions: for file in submission.files.all(): file.copy( dir.name, '{0}_{1}'.format(submission.submitter.username, os.path.basename(file.file.name))) m.addFilesByWildcard('{0}/*'.format(dir.name)) url = m.send() dir.cleanup() return redirect(url) else: context = {'form': form} return render(request, 'codemark/forms/plagiarism_form.html', context=context) else: form = forms.PlagiarismForm() context = {'form': form} return render(request, 'codemark/forms/plagiarism_form.html', context=context)
def moss_submit(self): moss_folder = 'uploads/moss_submission/assignment_{0}/'.format(self.id) submissions = self.get_student_and_latest_submissions( ) # include all students of the assignment's course annd submission can be empty submission_count = 0 for submission, student, _ in submissions: if submission != None: modifiable_file = submission.get_modifiable_file() path = moss_folder + basename(modifiable_file).replace( ".", "-" + submission.student.get_roll_number() + ".") touch(path) copyfile(modifiable_file, path) submission_count += 1 if submission_count == 0: logging.debug( "MOSS: No submissions available for generating Moss report") return False m = mosspy.Moss(settings.MOSS_USERID, "python") m.addBaseFile(self.assignment_file.url) m.addFilesByWildcard(moss_folder + "*.py") url = m.send() if url: logging.debug("MOSS: " + url) path = moss_folder + str(self.id) + ".html" touch(path) m.saveWebPage(url, path) return True else: logging.debug("MOSS: No url received.") return False
def send_to_moss(contest_id, output_dir, problem_dir, problem, lang): moss = mosspy.Moss(USERID, lang) moss.setIgnoreLimit(100000000) working_dir = os.path.join(problem_dir, problem) rex = re.compile('.*\\.{}$'.format(lang)) number_of_file = 0 for filename in os.listdir(working_dir): if rex.match(filename): filepath = os.path.join(working_dir, filename) try: moss.addFile(filepath, '{}_{}_{}'.format(contest_id, problem, filename)) number_of_file += 1 except: logger.error( "File {} is empty, check it again".format(filepath)) logger.info("{}_{}_{}".format(contest_id, problem, filename)) if number_of_file < 2: return None, None print("Checking plagiarism on problem {} and language {}...".format( problem, lang)) res_url = moss.send() print("Report Url: " + res_url) # create directory report_file = os.path.join( output_dir, "plagiarism_report_{}/{}_{}.html".format(contest_id, problem, lang)) create_dir(report_file) moss.saveWebPage(res_url, report_file) print("Saved report to {}".format(report_file)) name = '{}_{}_{}'.format(contest_id, problem, lang) return name, res_url