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
