128Autograder 5.0.1__tar.gz

128autograder-5.0.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: 128Autograder
+Version: 5.0.1
+Author: Gregory Bell
+Maintainer: Gregory Bell
+Requires-Python: >=3.11.0
+Requires-Dist: HybridJSONTestRunner==0.8.1
+Requires-Dist: dill==0.3.6
+Requires-Dist: Better-PyUnit-Format==0.2.3
+Requires-Dist: schema==0.7.5
+Requires-Dist: requests==2.31.0
+Requires-Dist: tomli==2.0.1
+Provides-Extra: dev
+Requires-Dist: coverage[toml]; extra == "dev"
+Requires-Dist: build; extra == "dev"

128autograder-5.0.1/pyproject.toml

@@ -0,0 +1,97 @@
+[build-system]
+    requires = ["setuptools >= 61"]
+    build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+    where=["source"]
+    exclude =["tests"]
+
+[tool.setuptools.dynamic]
+    version = {attr = "autograder_platform.__version__"}
+
+[project]
+    name = "128Autograder"
+    authors = [
+        { name = "Gregory Bell" }
+    ]
+    maintainers = [
+        { name = "Gregory Bell" }
+    ]
+
+    dynamic = ["version"]
+
+    requires-python = ">=3.11.0"
+
+    dependencies = [
+        "HybridJSONTestRunner==0.8.1",
+        "dill==0.3.6",
+        "Better-PyUnit-Format==0.2.3",
+        "schema==0.7.5",
+        "requests==2.31.0",
+        "tomli==2.0.1",
+    ]
+
+[project.optional-dependencies]
+    dev = [
+        "coverage[toml]",
+        "build",
+    ]
+
+[project.scripts]
+    run_gradescope = "autograder_cli.run_gradescope:tool"
+    run_prairielearn = "autograder_cli.run_prairielearn:tool"
+    test_my_work = "autograder_cli.run_local:tool"
+    run_autograder = "autograder_cli.run_local:tool"
+    create_gradescope_upload = "autograder_cli.create_upload:tool"
+    build_autograder = "autograder_cli.build_autograder:tool"
+
+[tool.pyright]
+    include = ["source"]
+
+    exclude = ["**__pycache__**"]
+    scrict = ["."]
+
+    executionEnvironments = [
+        { root = "tests", extraPaths = ["source", "source/utils/student", "source/utils"] }
+    ]
+
+[tool.coverage.run]
+    command_line = "-m unittest"
+    concurrency = ["multiprocessing"]
+    # Omit testing files, omit dynamic files, omit __init__.py
+    # Doing it at the run level as it will that means they wont be run in the first place
+    # Ignore build.py as its it is primarly covered by integration tests
+    omit = [
+        # TODO write unit tests for the CLI
+        # shouldnt be ignoring them, but also this needs to get out the door
+        # Technically the CLIs are covered via the e2e tests, and we dont seem to have a hole there anymore
+        "source/autograder_cli/*",
+        "sandbox/*",
+        "testPrograms/*",
+        "test_code",
+        "test_code.py",
+        "setup_code",
+        "tests/*",
+        "*/student_submission",
+        "__init__.py",
+        "Build.py",
+        "INJECTED_*",
+        "__getstate__*",
+        "__setstate__*",
+    ]
+
+[tool.coverage.report]
+    fail_under = 90
+    skip_empty = true
+    exclude_also = [
+        # Dont flag error conditions that cant be reached or that are just defensive
+        "raise AssertionError",
+        "raise NotImplementedError",
+        "raise EnvironmentError",
+        "raise AttributeError",
+        "raise InvalidRunner",
+        "if __name__ == .__main__.:",
+        # Don't complain about abstract methods, they aren't run:
+        "@(abc\\.)?abstractmethod",
+    ]
+

128autograder-5.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

128autograder-5.0.1/source/128Autograder.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: 128Autograder
+Version: 5.0.1
+Author: Gregory Bell
+Maintainer: Gregory Bell
+Requires-Python: >=3.11.0
+Requires-Dist: HybridJSONTestRunner==0.8.1
+Requires-Dist: dill==0.3.6
+Requires-Dist: Better-PyUnit-Format==0.2.3
+Requires-Dist: schema==0.7.5
+Requires-Dist: requests==2.31.0
+Requires-Dist: tomli==2.0.1
+Provides-Extra: dev
+Requires-Dist: coverage[toml]; extra == "dev"
+Requires-Dist: build; extra == "dev"

128autograder-5.0.1/source/128Autograder.egg-info/SOURCES.txt

@@ -0,0 +1,47 @@
+pyproject.toml
+source/128Autograder.egg-info/PKG-INFO
+source/128Autograder.egg-info/SOURCES.txt
+source/128Autograder.egg-info/dependency_links.txt
+source/128Autograder.egg-info/entry_points.txt
+source/128Autograder.egg-info/requires.txt
+source/128Autograder.egg-info/top_level.txt
+source/autograder_cli/__init__.py
+source/autograder_cli/build_autograder.py
+source/autograder_cli/create_upload.py
+source/autograder_cli/run_gradescope.py
+source/autograder_cli/run_local.py
+source/autograder_cli/run_prairielearn.py
+source/autograder_platform/__init__.py
+source/autograder_platform/cli.py
+source/autograder_platform/Executors/Environment.py
+source/autograder_platform/Executors/Executor.py
+source/autograder_platform/Executors/__init__.py
+source/autograder_platform/Executors/common.py
+source/autograder_platform/StudentSubmission/AbstractStudentSubmission.py
+source/autograder_platform/StudentSubmission/AbstractValidator.py
+source/autograder_platform/StudentSubmission/GenericValidators.py
+source/autograder_platform/StudentSubmission/ISubmissionProcess.py
+source/autograder_platform/StudentSubmission/SubmissionProcessFactory.py
+source/autograder_platform/StudentSubmission/__init__.py
+source/autograder_platform/StudentSubmission/common.py
+source/autograder_platform/StudentSubmissionImpl/__init__.py
+source/autograder_platform/StudentSubmissionImpl/Python/AbstractPythonImportFactory.py
+source/autograder_platform/StudentSubmissionImpl/Python/PythonEnvironment.py
+source/autograder_platform/StudentSubmissionImpl/Python/PythonFileImportFactory.py
+source/autograder_platform/StudentSubmissionImpl/Python/PythonModuleMockImportFactory.py
+source/autograder_platform/StudentSubmissionImpl/Python/PythonSubmission.py
+source/autograder_platform/StudentSubmissionImpl/Python/PythonSubmissionProcess.py
+source/autograder_platform/StudentSubmissionImpl/Python/PythonValidators.py
+source/autograder_platform/StudentSubmissionImpl/Python/Runners.py
+source/autograder_platform/StudentSubmissionImpl/Python/__init__.py
+source/autograder_platform/StudentSubmissionImpl/Python/common.py
+source/autograder_platform/Tasks/Task.py
+source/autograder_platform/Tasks/TaskRunner.py
+source/autograder_platform/Tasks/__init__.py
+source/autograder_platform/Tasks/common.py
+source/autograder_platform/TestingFramework/Assertions.py
+source/autograder_platform/TestingFramework/SingleFunctionMock.py
+source/autograder_platform/TestingFramework/__init__.py
+source/autograder_platform/config/Config.py
+source/autograder_platform/config/__init__.py
+source/autograder_platform/config/common.py

128autograder-5.0.1/source/128Autograder.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

128autograder-5.0.1/source/128Autograder.egg-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+build_autograder = autograder_cli.build_autograder:tool
+create_gradescope_upload = autograder_cli.create_upload:tool
+run_autograder = autograder_cli.run_local:tool
+run_gradescope = autograder_cli.run_gradescope:tool
+run_prairielearn = autograder_cli.run_prairielearn:tool
+test_my_work = autograder_cli.run_local:tool

128autograder-5.0.1/source/128Autograder.egg-info/requires.txt

@@ -0,0 +1,10 @@
+HybridJSONTestRunner==0.8.1
+dill==0.3.6
+Better-PyUnit-Format==0.2.3
+schema==0.7.5
+requests==2.31.0
+tomli==2.0.1
+
+[dev]
+coverage[toml]
+build

128autograder-5.0.1/source/128Autograder.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+autograder_cli
+autograder_platform

128autograder-5.0.1/source/autograder_cli/build_autograder.py

@@ -0,0 +1,314 @@
+import os
+import re
+import shutil
+from enum import Enum
+from typing import List, Dict, Callable
+
+from autograder_platform.cli import AutograderCLITool
+from autograder_platform.config.Config import AutograderConfigurationBuilder, AutograderConfiguration
+
+
+class FilesEnum(Enum):
+    PUBLIC_TEST = 0
+    PRIVATE_TEST = 1
+    PUBLIC_DATA = 2
+    PRIVATE_DATA = 3
+    STARTER_CODE = 4
+    CONFIG_FILE = 5
+
+
+class Build:
+    IGNORE = ["__pycache__"]
+
+    def __init__(self, config: AutograderConfiguration, sourceRoot, binRoot, version) -> None:
+        self.config = config
+        self.generationDirectory = os.path.join(binRoot, "generation")
+        self.distDirectory = os.path.join(binRoot, "dist")
+        self.binRoot = binRoot
+        self.sourceDir = sourceRoot
+        self.version = version
+
+    @staticmethod
+    def _discoverTestFiles(allowPrivate: bool,
+                           privateTestFileRegex: re.Pattern, publicTestFileRegex: re.Pattern,
+                           testDirectory: str,
+                           discoveredPrivateFiles: List[str], discoveredPublicFiles: List[str]):
+        """
+        Description
+        ---
+
+        This function discovers the test files in the testDirectory and puts them in the correct list
+        based on the regex matches.
+
+        Note: If allowPrivate is false, then all files that match the private regex will be added to the public list
+
+        :param allowPrivate: If private files should be treated as private
+        :param privateTestFileRegex: The regex pattern used to match private test files
+        :param publicTestFileRegex: The regex pattern used to match public test files
+        :param discoveredPrivateFiles: The list that contains the private files to be copied
+        :param discoveredPublicFiles: The list that contains the public files to be copied
+        """
+
+        # test discovery is non recursive for now
+        test_files = [file for file in os.listdir(testDirectory) if os.path.isfile(os.path.join(testDirectory, file))]
+
+        for file in test_files:
+            path = os.path.join(testDirectory, file)
+            # Dont need to worry about double checking, the private test will only be run once in both of these cases
+            if allowPrivate and privateTestFileRegex.match(file):
+                discoveredPrivateFiles.append(path)
+            elif publicTestFileRegex.match(file) or privateTestFileRegex.match(file):
+                discoveredPublicFiles.append(path)
+
+    @staticmethod
+    def _discoverDataFiles(allowPrivate: bool, dataFilesSource: str,
+                           discoveredPrivateFiles: List[str], discoveredPublicFiles: List[str]):
+        """
+        Description
+        ---
+
+        This function recursively discovers the data files in the dataFilesSource.
+        As opposed to the test file function, this will mark files as private if they contain 'private' anywhere in the path.
+
+        Note: if allowPrivate is false, then all files that would otherwise be private will be added to the public list
+
+        In the godforsaken event that some how we have a directory structure that exceeds 1000 folders, this will fail
+        due to a recursion error
+
+        :param allowPrivate: If private files should be treated as private
+        :param dataFilesSource: The current search directory
+        :param discoveredPrivateFiles: The list that contains the private files to be copied
+        :param discoveredPublicFiles: the list that contains the public files to be copied
+        """
+
+        for file in os.listdir(dataFilesSource):
+            # ignore hidden files + directories
+            if file[0] == ".":
+                continue
+
+            path = os.path.join(dataFilesSource, file)
+
+            # ignore any and all test files
+            if os.path.isfile(path) and "test" in file.lower():
+                continue
+
+            if os.path.isdir(path):
+                Build._discoverDataFiles(allowPrivate, path, discoveredPrivateFiles, discoveredPublicFiles)
+                continue
+
+            if allowPrivate and "private" in path.lower():
+                discoveredPrivateFiles.append(path)
+                continue
+
+            discoveredPublicFiles.append(path)
+
+    def discoverFiles(self) -> Dict[FilesEnum, List[str]]:
+        """
+        Description
+        ---
+
+        This function discovers all of the user defined files to copy.
+        See :ref:`_discoverTestFiles` and :ref:`_discoverDataFiles` for more information on how this process works
+
+        :returns: A map containing all the user defined files to copy
+        """
+        config = self.config.build
+
+        files: Dict[FilesEnum, List[str]] = {
+            FilesEnum.PUBLIC_TEST: [],
+            FilesEnum.PRIVATE_TEST: [],
+            FilesEnum.PUBLIC_DATA: [],
+            FilesEnum.PRIVATE_DATA: [],
+            FilesEnum.STARTER_CODE: [],
+            FilesEnum.CONFIG_FILE: [],
+        }
+
+        self._discoverTestFiles(config.allow_private,
+                                re.compile(config.private_tests_regex), re.compile(config.public_tests_regex),
+                                self.config.config.test_directory,
+                                files[FilesEnum.PRIVATE_TEST], files[FilesEnum.PUBLIC_TEST])
+
+        # imo, this is not worth moving into its function atm
+        if config.use_starter_code:
+            # we can assume that the file exists if the config has it
+            files[FilesEnum.STARTER_CODE].append(config.starter_code_source)
+
+        if config.use_data_files:
+            self._discoverDataFiles(config.allow_private, config.data_files_source,
+                                    files[FilesEnum.PRIVATE_DATA], files[FilesEnum.PUBLIC_DATA])
+
+        files[FilesEnum.CONFIG_FILE] = [os.path.join(self.sourceDir, "config.toml")]
+
+        return files
+
+    @staticmethod
+    def copy(src, dest):
+        if os.path.isdir(src):
+            shutil.copytree(src, dest)
+            return
+
+        shutil.copy(src, dest)
+
+    def createFolders(self):
+        # clean build if it exists
+        if os.path.exists(self.binRoot):
+            try:
+                shutil.rmtree(self.binRoot, ignore_errors=True)
+            except OSError:
+                print("WARN: Failed to clean bin directory")
+
+        # create directories
+        os.makedirs(self.generationDirectory, exist_ok=True)
+        os.makedirs(self.distDirectory, exist_ok=True)
+
+    @staticmethod
+    def createSetupForGradescope(path: str, version: str):
+        with open(os.path.join(path, "setup.sh"), "w") as w:
+            w.write(
+                "apt-get install python3.11 -y\n"
+                "apt-get install python3-pip -y\n"
+                # "apt-get install -y libgbm-dev xvfb\n"
+                "pip3 install --upgrade pip\n"
+                f"pip3 install 128Autograder=={version}\n"
+            )
+
+    @staticmethod
+    def createRunFileForGradescope(path: str):
+        with open(os.path.join(path, "run_autograder"), "w") as w:
+            w.write(
+                "#!/bin/bash\n"
+                "pushd source > /dev/null || echo 'Autograder failed to open source'\n"
+                "run_gradescope\n"
+                "popd > /dev/null || true\n"
+            )
+
+    @staticmethod
+    def createRunForPrairieLearn(path: str):
+        with open(os.path.join(path, "run_autograder"), "w") as w:
+            w.write(
+                "#!/bin/bash\n"
+                "pushd source > /dev/null || echo 'Autograder failed to open source'\n"
+                "run_prairielearn\n"
+                "popd > /dev/null || true\n"
+            )
+
+    @staticmethod
+    def generateDocker(generationPath: str, platform, files: Dict[FilesEnum, List[str]], version: str,
+                       setupFileGenerator: Callable[[str, str], None], runFileGenerator: Callable[[str], None]):
+        generationPath = os.path.join(generationPath, "docker", platform)
+        os.makedirs(generationPath, exist_ok=True)
+
+        setupFileGenerator(generationPath, version)
+        runFileGenerator(generationPath)
+
+        for key, listOfFiles in files.items():
+            if key is FilesEnum.STARTER_CODE:
+                continue
+
+            for file in listOfFiles:
+                destPath = os.path.join(generationPath, file)
+                os.makedirs(os.path.dirname(destPath), exist_ok=True)
+                Build.copy(file, destPath)
+
+    @staticmethod
+    def generateStudent(generationPath: str, files: Dict[FilesEnum, List[str]], studentWorkFolder: str):
+        generationPath = os.path.join(generationPath, "student")
+        os.makedirs(generationPath, exist_ok=True)
+
+        # create student_work folder
+        studentWorkFolder = os.path.join(generationPath, studentWorkFolder)
+        os.makedirs(studentWorkFolder, exist_ok=True)
+
+        for file in files[FilesEnum.PUBLIC_TEST]:
+            destPath = os.path.join(generationPath, file)
+            os.makedirs(os.path.dirname(destPath), exist_ok=True)
+            Build.copy(file, destPath)
+
+        for file in files[FilesEnum.PUBLIC_DATA]:
+            destPath = os.path.join(generationPath, file)
+            os.makedirs(os.path.dirname(destPath), exist_ok=True)
+            Build.copy(file, destPath)
+            # also add to student work folder
+            destPath = os.path.join(studentWorkFolder, os.path.basename(file))
+            Build.copy(file, destPath)
+
+        for file in files[FilesEnum.STARTER_CODE]:
+            destPath = os.path.join(studentWorkFolder, os.path.basename(file))
+            Build.copy(file, destPath)
+
+        for file in files[FilesEnum.CONFIG_FILE]:
+            destPath = os.path.join(generationPath, os.path.basename(file))
+            Build.copy(file, destPath)
+
+        # create .keep so that we dont loose the file
+        with open(os.path.join(studentWorkFolder, ".keep"), "w") as w:
+            w.write("DO NOT WRITE YOUR CODE HERE!\nCreate a *new* file in this directory!!!")
+
+    @staticmethod
+    def createDist(distType: str, generationPath: str, distPath: str, assignmentName: str):
+        generationPath = os.path.join(generationPath, distType)
+        if not os.path.exists(generationPath) or not os.path.isdir(generationPath):
+            raise AttributeError(f"Invalid generation path: {generationPath}")
+
+        os.makedirs(distPath, exist_ok=True)
+
+        assignmentName += f"-{'-'.join(distType.split('/'))}"
+        distPath = os.path.join(distPath, assignmentName)
+
+        shutil.make_archive(distPath, "zip", root_dir=generationPath)
+
+    def build(self):
+        files = self.discoverFiles()
+
+        self.createFolders()
+
+        if self.config.build.build_gradescope:
+            self.generateDocker(self.generationDirectory, "gradescope", files, self.version,
+                                self.createSetupForGradescope, self.createRunFileForGradescope)
+            self.createDist("docker/gradescope", self.generationDirectory, self.distDirectory,
+                            f"{self.config.semester}_{self.config.assignment_name}")
+        if self.config.build.build_prairie_learn:
+            # this build is a touch bigger than it needs to be, but for now I'm not super concerned about it
+            self.generateDocker(self.generationDirectory, "prairielearn", files, self.version,
+                                lambda _, __: None, self.createRunForPrairieLearn)
+            self.createDist("docker/prairielearn", self.generationDirectory, self.distDirectory,
+                            f"{self.config.semester}_{self.config.assignment_name}")
+
+        if self.config.build.build_student:
+            self.generateStudent(self.generationDirectory, files,
+                                 self.config.build.student_work_folder)
+            self.createDist("student", self.generationDirectory, self.distDirectory,
+                            f"{self.config.semester}_{self.config.assignment_name}")
+
+
+class BuildAutograderCLI(AutograderCLITool):
+    def __init__(self):
+        super().__init__(f"Builder v{AutograderCLITool.get_version()}")
+
+    def configure_options(self):
+        self.parser.add_argument("--source", default=".", help="Autograder source root")
+        self.parser.add_argument("-o", default="./bin", help="Output folder")
+
+    def run(self) -> bool:
+        self.configure_options()
+        self.load_config()
+
+        build = Build(self.config, self.arguments.source, self.arguments.o, self.get_version())
+
+        build.build()
+
+        return True
+
+    def set_config_arguments(self, configBuilder: AutograderConfigurationBuilder[AutograderConfiguration]):
+        pass
+
+
+tool = BuildAutograderCLI().run
+
+if __name__ == "__main__":
+    res = tool()
+
+    if res:
+        exit(0)
+
+    exit(1)

128autograder-5.0.1/source/autograder_cli/create_upload.py

@@ -0,0 +1,103 @@
+import getpass
+import os
+import sys
+from zipfile import ZipFile
+
+
+def buildZipName() -> str:
+    """
+    This function generates the zip file name and sets a fallback if the user's name can't be determined
+    :return: the generated zip file name
+    """
+    DEFAULT_NAME: str = "csci_128_student"
+    zipName: str = ""
+
+    try:
+        # Get user can throw an exception if it fails to look up the username in the password database
+        userName = getpass.getuser().lower()
+        # replace spaces with underscore bc spaces make me sad
+        userName = userName.replace(" ", "_")
+
+        zipName += userName
+
+    except KeyError:
+        print(f"Can't automatically determine user name. Defaulting to {DEFAULT_NAME}")
+        zipName += DEFAULT_NAME
+
+    zipName += "-submission"
+    zipName += ".zip"
+
+    return zipName
+
+
+def addFolderToZip(_currentZipBuffer: ZipFile, _directoryToAdd: str) -> None:
+    """
+    This function allows us to recursively descend through the directory structure to
+    collect all of a student's submitted files
+    :param _currentZipBuffer: the zip file that is currently being written.
+    :param _directoryToAdd: the directory that needs to be added
+    """
+
+    # Ignore hidden directories
+    if _directoryToAdd[0] == ".":
+        return
+
+    # Ignore directories python directories
+    if "__" in _directoryToAdd:
+        return
+
+    print(f"\tEntering {_directoryToAdd}...")
+
+    for file in os.listdir(_directoryToAdd):
+        if os.path.isfile(_directoryToAdd + file) and file[-3:] == ".py":
+            print(f"\tAdding {_directoryToAdd + file}...")
+            _currentZipBuffer.write(_directoryToAdd + file)
+        elif os.path.isfile(_directoryToAdd + file):
+            print(f"\tIgnoring {_directoryToAdd + file}...")
+        else:
+            addFolderToZip(_currentZipBuffer, _directoryToAdd + file + "/")
+
+
+def generateZipFile(_submissionDirectory: str) -> None:
+    """
+    This function generates the zip file needed for gradescope.
+    :param _submissionDirectory: the directory that the students work is in
+    """
+    GREEN_COLOR: str = u"\u001b[32m"
+    RESET_COLOR: str = u"\u001b[0m"
+
+    print("Generating gradescope upload...")
+
+    zipName: str = buildZipName()
+
+    with ZipFile(zipName, 'w') as submissionZip:
+        os.chdir(_submissionDirectory)
+        for file in os.listdir("."):
+            if os.path.isfile(file) and file[-3:] == ".py":
+                print(f"\tAdding {_submissionDirectory + file} to zip...")
+                submissionZip.write(file)
+            elif os.path.isfile(file):
+                print(f"\tIgnoring {_submissionDirectory + file}...")
+            else:
+                addFolderToZip(submissionZip, file + "/")
+
+    print("...Done.")
+    print(f"\n\n{GREEN_COLOR}Submit {zipName} to Gradescope under the corresponding assignment.{RESET_COLOR}")
+
+
+
+def tool():  # pragma: no cover
+    submissionDirectory = "student_work"
+
+    if len(sys.argv) == 2:
+        submissionDirectory = sys.argv[1]
+
+    # need to make sure to that we have a / at the end of the path
+    if submissionDirectory[-1:] != '/':
+        submissionDirectory += "/"
+
+    generateZipFile(submissionDirectory)
+
+
+if __name__ == "__main__":
+    tool()