Add basic checks

Author: sushinoya

Diff for: checks/__init__.py

@@ -1,3 +1,7 @@
 from checks.base import BaseChecker
 from checks.repo_not_forked import RepoNotForkedChecker
 from checks.commit_only_during_hackathon import CommitOnlyDuringHackathonChecker
+from checks.only_valid_authors import OnlyValidAuthorsChecker
+from checks.substantial_authors_contributions import SubstantialAuthorsContributionsChecker
+# from checks.source_code_not_similar_to_other_user_project import SourceCodeSimilarityChecker
+# from checks.no_commit_overlap_with_other_user_project import NoCommitOverlapWithOtherUserProjectChecker

Diff for: checks/base.py

@@ -1,12 +1,12 @@
 from abc import ABCMeta, abstractmethod
-from datatypes import Submission, HackathonConfig
+from datatypes import Submission, HackathonConfig, RepoInfo
 from typing import Tuple, Optional
 
 
 class BaseChecker(metaclass=ABCMeta):
     @staticmethod
     @abstractmethod
-    def perform_check(submission: Submission, config: HackathonConfig) -> Tuple[bool, Optional[str]]:
+    def perform_check(submission: Submission, config: HackathonConfig, repo_info: RepoInfo) -> Tuple[bool, Optional[str]]:
         raise NotImplementedError
 
     @property

Diff for: checks/commit_only_during_hackathon.py

@@ -1,12 +1,33 @@
 from checks.base import BaseChecker
-from datatypes import Submission, HackathonConfig
+from datatypes import Submission, HackathonConfig, RepoInfo
 from typing import Tuple, Optional
 
 
 class CommitOnlyDuringHackathonChecker(BaseChecker):
 	check_name = "commit_only_during_hackathon"
 
 	@staticmethod
-	def perform_check(submission: Submission, config: HackathonConfig) -> Tuple[bool, Optional[str]]:
-		# TODO Implement check method
-		return True, "Committed only during hackathon"
+	def perform_check(submission: Submission, config: HackathonConfig, repo_info: RepoInfo) -> Tuple[bool, Optional[str]]:
+		sorted_commits = sorted(repo_info.commits, key=lambda c: c.last_modified_datetime)
+		last_commit_before_hackathon_started, first_commit_after_hackathon_ended = None, None
+
+		for commit in sorted_commits:
+			if commit.last_modified_datetime < config.start_at:
+				last_commit_before_hackathon_started = commit
+
+			if commit.last_modified_datetime > config.end_at:
+				first_commit_after_hackathon_ended = commit
+				break
+
+		if not last_commit_before_hackathon_started and not first_commit_after_hackathon_ended:
+			return True, None
+
+		remarks = ""
+
+		if last_commit_before_hackathon_started is not None:
+			remarks += f"The last commit before the hackathon is {last_commit_before_hackathon_started.html_url}\n"
+
+		if first_commit_after_hackathon_ended is not None:
+			remarks += f"The first commit after the hackathon is {first_commit_after_hackathon_ended.html_url}"
+
+		return False, remarks

Diff for: checks/no_commit_overlap_with_other_user_project.py

@@ -0,0 +1,13 @@
+from checks.base import BaseChecker
+from datatypes import Submission, HackathonConfig, RepoInfo
+from typing import Tuple, Optional
+
+
+class NoCommitOverlapWithOtherUserProjectChecker(BaseChecker):
+    check_name = "no_commit_overlap_with_other_user_project"
+
+    @staticmethod
+    def perform_check(submission: Submission, config: HackathonConfig, repo_info: RepoInfo) -> Tuple[
+        bool, Optional[str]]:
+        # TODO Implement check method
+        return True, "No commit overlap with other projects found"

Diff for: checks/only_valid_authors.py

@@ -0,0 +1,22 @@
+from checks.base import BaseChecker
+from datatypes import Submission, HackathonConfig, RepoInfo
+from typing import Tuple, Optional
+
+
+class OnlyValidAuthorsChecker(BaseChecker):
+    check_name = "only_valid_authors"
+
+    @staticmethod
+    def perform_check(submission: Submission, config: HackathonConfig, repo_info: RepoInfo) -> Tuple[bool, Optional[str]]:
+        contributors = {commit.author.login for commit in repo_info.commits}
+        expected_contributors = set(submission.authors)
+
+        if contributors == expected_contributors:
+            return True, None
+        elif contributors.issubset(expected_contributors):
+            people_who_didnt_contribute = ", ".join(expected_contributors - contributors)
+            return True, f"{people_who_didnt_contribute} did not commit anything"
+        else:
+            expected_contributors_names = ", ".join(expected_contributors)
+            actual_contributors_names = ", ".join(contributors)
+            return False, f"Expected {expected_contributors_names} to author commits but instead {actual_contributors_names} did"

Diff for: checks/repo_not_forked.py

@@ -1,12 +1,14 @@
 from checks.base import BaseChecker
-from datatypes import Submission, HackathonConfig
+from datatypes import Submission, HackathonConfig, RepoInfo
 from typing import Tuple, Optional
 
 
 class RepoNotForkedChecker(BaseChecker):
 	check_name = "repo_not_forked"
 
 	@staticmethod
-	def perform_check(submission: Submission, config: HackathonConfig) -> Tuple[bool, Optional[str]]:
-		# TODO Implement check method
-		return True, "We won"
+	def perform_check(submission: Submission, config: HackathonConfig, repo_info: RepoInfo) -> Tuple[bool, Optional[str]]:
+		if not repo_info.repo.parent:
+			return True, None
+
+		return False, f"Project was forked from {repo_info.repo.parent}"

Diff for: checks/source_code_not_similar_to_other_user_project.py

@@ -0,0 +1,12 @@
+from checks.base import BaseChecker
+from datatypes import Submission, HackathonConfig, RepoInfo
+from typing import Tuple, Optional
+
+
+class SourceCodeSimilarityChecker(BaseChecker):
+    check_name = "source_code_not_similar_to_other_user_project"
+
+    @staticmethod
+    def perform_check(submission: Submission, config: HackathonConfig, repo_info: RepoInfo) -> Tuple[bool, Optional[str]]:
+        # TODO Implement check method
+        return True, "Not Similar"

Diff for: checks/substantial_authors_contributions.py

@@ -0,0 +1,16 @@
+from checks.base import BaseChecker
+from datatypes import Submission, HackathonConfig, RepoInfo
+from typing import Tuple, Optional
+
+
+class SubstantialAuthorsContributionsChecker(BaseChecker):
+    check_name = "substantial_authors_contributions"
+
+    @staticmethod
+    def perform_check(submission: Submission, config: HackathonConfig, repo_info: RepoInfo) -> Tuple[bool, Optional[str]]:
+        num_commits = len(repo_info.commits)
+
+        if num_commits > 5:
+            return True, None
+
+        return False, f"This project only has {num_commits} commits"

Diff for: checks/utils.py

@@ -0,0 +1,47 @@
+from github import Github
+from datatypes import RepoInfo
+from typing import Optional
+from datetime import datetime
+from pytz import UTC
+import os
+
+
+# GitHub Related Utils
+def get_github() -> Github:
+	return Github(os.getenv("GITHUB_ACCESS_TOKEN"))
+
+
+def get_user(github_username):
+	try:
+		usr = get_github().get_user(github_username)
+	except Exception as e:
+		return None
+
+
+def get_repo_id(repo_url):
+	if repo_url.endswith('.git'):
+		repo_url = repo_url[:-4]
+	return repo_url.rstrip('/').split("github.com/")[1]
+
+
+def parse_commit_datetime(datetime_str) -> datetime:
+	format = "%Y-%m-%dT%H:%M:%SZ"
+	alternate_format = "%a, %d %b %Y %H:%M:%S %Z"
+	return UTC.localize(datetime.strptime(datetime_str, format))
+
+
+def get_repo_info(repo_url) -> Optional[RepoInfo]:
+	repo_id = get_repo_id(repo_url)
+	try:
+		repo = get_github().get_repo(repo_id)
+		commits = list(repo.get_commits())
+
+		for commit in commits:
+			datetime_str = commit.raw_data['commit']['author']['date']
+			commit.last_modified_datetime = parse_commit_datetime(datetime_str)
+
+		return RepoInfo(repo, commits)
+
+	except Exception as e:
+		print(e)
+		return None