dlai-grader 1.22.0__py3-none-any.whl → 2.0b1__py3-none-any.whl

dlai_grader/__init__.py

@@ -6,6 +6,6 @@ from . import grading
 from . import types
 
 
-__version__ = "1.22.0"
+__version__ = "2.0b1"
 __author__ = "Andres Zarta"
 __credits__ = "DeepLearning.AI"

dlai_grader/config.py

@@ -2,12 +2,11 @@ import os
 import re
 import csv
 from dataclasses import dataclass
-from typing import Dict
 
 
 def parse_conf(
     path: str = "./.conf",
-) -> Dict[str, str]:
+) -> dict[str, str]:
     """Parses variables from .conf file
 
     Args:
@@ -45,10 +44,9 @@ class Config:
     submission_workdir: str = "./submission/"
     solution_workdir: str = "./solution/"
     solution_file: str = "solution.ipynb"
-    solution_file_path: str = os.path.join(solution_workdir, solution_file)
+    solution_file_path: str = ""
     submission_file: str = "submission.ipynb"
-    submission_file_path: str = os.path.join(submission_workdir, submission_file)
-    feedback_file_path: str = "/shared/feedback.json"
+    submission_file_path: str = ""
     part_id: str = get_part_id()
     latest_version: str = (
         parse_conf()["GRADER_VERSION"] if os.path.exists("./.conf") else ""
@@ -56,3 +54,12 @@ class Config:
     assignment_name: str = (
         parse_conf()["ASSIGNMENT_NAME"] if os.path.exists("./.conf") else ""
     )
+
+    def __post_init__(self):
+        # This is where we set the file paths after the instance variables are initialized
+        self.solution_file_path = os.path.join(
+            self.solution_workdir, self.solution_file
+        )
+        self.submission_file_path = os.path.join(
+            self.submission_workdir, self.submission_file
+        )

dlai_grader/grading.py

@@ -1,75 +1,96 @@
 from dataclasses import dataclass
 from functools import wraps
-from typing import Any, Callable, List, Tuple, Union
+from typing import Any, Callable
 from types import ModuleType
 
 
 @dataclass
 class LearnerSubmission:
-    """Class that represents a file from the learner. Useful when grading does not depend on the notebook"""
+    """Class that represents a file from the learner. Useful when grading does not depend on the notebook."""
 
     submission: Any = None
 
 
-learner_submission = Union[ModuleType, LearnerSubmission]
+learner_submission = ModuleType | LearnerSubmission
 
 
 @dataclass
 class test_case:
-    """Class that represents a test case"""
+    """Class that represents a test case."""
 
     msg: str = ""
     want: Any = None
     got: Any = None
     failed: bool = False
 
+    def fail(self):
+        """Sets the failed attribute to True."""
+        self.failed = True
+
 
 @dataclass
 class aggregated_test_case:
-    """Class that represents an aggregated collection of test cases"""
+    """Class that represents an aggregated collection of test cases."""
 
     test_name: str
-    tests: List[test_case]
+    tests: list[test_case]
+
 
+def compute_grading_score(test_cases: list[test_case]) -> tuple[float, str]:
+    """
+    Computes the score based on the number of failed and total cases.
 
-def compute_grading_score(
-    test_cases: List[test_case],
-) -> Tuple[float, str]:
-    """Computes the score based on the number of failed and total cases.
     Args:
         test_cases (List): Test cases.
+
     Returns:
         Tuple[float, str]: The grade and feedback message.
-    """
 
+    """
     num_cases = len(test_cases)
     if num_cases == 0:
-        return (
-            0.0,
-            "The grader was unable to generate test cases for your implementation. This suggests a bug with your code, please revise your solution and try again.",
-        )
+        msg = "The grader was unable to generate test cases for your implementation. This suggests a bug with your code, please revise your solution and try again."
+        return 0.0, msg
 
     failed_cases = [t for t in test_cases if t.failed]
     score = 1.0 - len(failed_cases) / num_cases
-    feedback_msg = "All tests passed! Congratulations!"
+    score = round(score, 2)
+
+    if not failed_cases:
+        msg = "All tests passed! ✅ Congratulations! 🎉"
+        return 1.0, msg
+
+    feedback_msg = ""
+    # if print_passed_tests:
+    #     passed_cases = [t for t in test_cases if not t.failed]
+    #     for passed_case in passed_cases:
+    #         feedback_msg += f"✅ {passed_case.msg}.\n"
 
     if failed_cases:
-        feedback_msg = ""
         for failed_case in failed_cases:
-            feedback_msg += f"Failed test case: {failed_case.msg}.\nExpected:\n{failed_case.want},\nbut got:\n{failed_case.got}.\n\n"
-        return round(score, 2), feedback_msg
+            feedback_msg += f"❌ {failed_case.msg}.\n"
+
+            if failed_case.want:
+                feedback_msg += f"Expected:\n{failed_case.want}\n"
+
+            if failed_case.got:
+                feedback_msg += f"but got:\n{failed_case.got}\n\n"
 
     return score, feedback_msg
 
 
 def compute_aggregated_grading_score(
-    aggregated_test_cases: List[aggregated_test_case],
-) -> Tuple[float, str]:
-    """Computes the score based on the number of failed and total cases.
+    aggregated_test_cases: list[aggregated_test_case],
+) -> tuple[float, str]:
+    """
+    Computes the score based on the number of failed and total cases.
+
     Args:
         aggregated_test_cases (List): Aggregated test cases for every part.
+
     Returns:
         Tuple[float, str]: The grade and feedback message.
+
     """
     scores = []
     msgs = []
@@ -98,11 +119,14 @@ def compute_aggregated_grading_score(
 def object_to_grade(
     origin_module: learner_submission,
     *attr_names: str,
-) -> Callable[[Callable[[Any], List[test_case]]], Callable[[Any], List[test_case]]]:
-    """Used as a parameterized decorator to get any number of attributes from a module.
+) -> Callable[[Callable[[Any], list[test_case]]], Callable[[Any], list[test_case]]]:
+    """
+    Used as a parameterized decorator to get any number of attributes from a module.
+
     Args:
         origin_module (ModuleType): A module.
-        attrs_name (Tuple[str, ...]): Names of the attributes to extract from the module.
+        *attrs_name (Tuple[str, ...]): Names of the attributes to extract from the module.
+
     """
 
     def middle(func):
@@ -120,11 +144,13 @@ def object_to_grade(
     return middle
 
 
-def print_feedback(test_cases: List[test_case]) -> None:
-    """Prints feedback of public unit tests within notebook.
+def print_feedback(test_cases: list[test_case]) -> None:
+    """
+    Prints feedback of public unit tests within notebook.
 
     Args:
         test_cases (List[test_case]): List of public test cases.
+
     """
     failed_cases = [t for t in test_cases if t.failed]
     feedback_msg = "\033[92m All tests passed!"
@@ -137,16 +163,18 @@ def print_feedback(test_cases: List[test_case]) -> None:
     print(feedback_msg)
 
 
-def graded_obj_missing(test_cases: List[test_case]) -> bool:
-    """Check if the object to grade was found in the learned module.
+def graded_obj_missing(test_cases: list[test_case]) -> bool:
+    """
+    Check if the object to grade was found in the learned module.
 
     Args:
         test_cases (List[test_case]): List of test cases.
 
     Returns:
         bool: True if object is missing. False otherwise.
+
     """
-    if len(test_cases) == 1 and test_cases[0].got == type(None):
+    if len(test_cases) == 1 and test_cases[0].got is type(None):
         return True
 
     return False

dlai_grader/io.py

@@ -1,27 +1,29 @@
-import os
 import json
+import os
 import shutil
-import tarfile
-import nbformat
-import jupytext
 import subprocess
+import tarfile
+from contextlib import contextmanager, redirect_stderr, redirect_stdout
 from os import devnull
 from textwrap import dedent
 from zipfile import ZipFile
+
+import jupytext
+import nbformat
 from nbformat.notebooknode import NotebookNode
-from contextlib import contextmanager, redirect_stderr, redirect_stdout
+
 from .notebook import (
     add_metadata_all_code_cells,
     add_metadata_code_cells_without_pattern,
-    tag_code_cells,
     solution_to_learner_format,
+    tag_code_cells,
 )
 from .templates import load_templates
 
 
 @contextmanager
 def suppress_stdout_stderr():
-    """A context manager that redirects stdout and stderr to devnull"""
+    """A context manager that redirects stdout and stderr to devnull."""
     with open(devnull, "w") as fnull:
         with redirect_stderr(fnull) as err, redirect_stdout(fnull) as out:
             yield (err, out)
@@ -30,11 +32,15 @@ def suppress_stdout_stderr():
 def read_notebook(
     path: str,
 ) -> NotebookNode:
-    """Reads a notebook found in the given path and returns a serialized version.
+    """
+    Reads a notebook found in the given path and returns a serialized version.
+
     Args:
         path (str): Path of the notebook file to read.
+
     Returns:
         NotebookNode: Representation of the notebook following nbformat convention.
+
     """
     return nbformat.read(path, as_version=nbformat.NO_CONVERT)
 
@@ -42,10 +48,12 @@ def read_notebook(
 def tag_notebook(
     path: str,
 ) -> None:
-    """Adds 'graded' tag to all code cells of a notebook.
+    """
+    Adds 'graded' tag to all code cells of a notebook.
 
     Args:
         path (str): Path to the notebook.
+
     """
     nb = read_notebook(path)
     nb = tag_code_cells(nb)
@@ -53,10 +61,12 @@ def tag_notebook(
 
 
 def undeletable_notebook(path: str) -> None:
-    """Makes all code cells of a notebook non-deletable.
+    """
+    Makes all code cells of a notebook non-deletable.
 
     Args:
         path (str): Path to the notebook.
+
     """
     nb = read_notebook(path)
     nb = add_metadata_all_code_cells(nb, {"deletable": False})
@@ -64,13 +74,17 @@ def undeletable_notebook(path: str) -> None:
 
 
 def uneditable_notebook(path: str) -> None:
-    """Makes all non-graded code cells of a notebook non-editable.
+    """
+    Makes all non-graded code cells of a notebook non-editable.
 
     Args:
         path (str): Path to the notebook.
+
     """
     nb = read_notebook(path)
-    nb = add_metadata_code_cells_without_pattern(nb, {"editable": False})
+    nb = add_metadata_code_cells_without_pattern(
+        nb, {"editable": False}, ignore_pattern="^# EDITABLE"
+    )
     jupytext.write(nb, path)
 
 
@@ -79,12 +93,14 @@ def extract_tar(
     destination: str,
     post_cleanup: bool = True,
 ) -> None:
-    """Extracts a tar file unto the desired destination.
+    """
+    Extracts a tar file unto the desired destination.
 
     Args:
         file_path (str): Path to tar file.
         destination (str): Path where to save uncompressed files.
         post_cleanup (bool, optional): If true, deletes the compressed tar file. Defaults to True.
+
     """
     with tarfile.open(file_path, "r") as my_tar:
         my_tar.extractall(destination)
@@ -118,14 +134,16 @@ def send_feedback(
     feedback_path: str = "/shared/feedback.json",
     err: bool = False,
 ) -> None:
-    """Sends feedback to the learner.
+    """
+    Sends feedback to the learner.
+
     Args:
         score (float): Grading score to show on Coursera for the assignment.
         msg (str): Message providing additional feedback.
         feedback_path (str): Path where the json feedback will be saved. Defaults to /shared/feedback.json
         err (bool, optional): True if there was an error while grading. Defaults to False.
-    """
 
+    """
     post = {"fractionalScore": score, "feedback": msg}
     print(json.dumps(post))
 
@@ -166,7 +184,7 @@ def update_grader_version() -> str:
 
     new_lines = []
     for l in lines:
-        if ("GRADER_VERSION" in l) and (not "TAG_ID" in l):
+        if ("GRADER_VERSION" in l) and ("TAG_ID" not in l):
             _, v = l.split("=")
             num_v = int(v)
             new_v = num_v + 1
@@ -227,13 +245,23 @@ def init_grader() -> None:
     write_file_from_template("./Makefile", template_dict["makefile"])
     write_file_from_template("./.conf", template_dict["conf"])
     write_file_from_template("./entry.py", template_dict["entry_py"])
+    write_file_from_template(
+        "./copy_assignment_to_submission.sh",
+        template_dict["copy_assignment_to_submission_sh"],
+    )
     write_file_from_template("./requirements.txt", "dlai-grader")
-    os.makedirs("data")
+    write_file_from_template("./.env", "")
+
     os.makedirs("learner")
     os.makedirs("mount")
-    os.makedirs("solution")
     os.makedirs("submission")
 
+    if "COPY data/ /grader/data/" in template_dict["dockerfile"]:
+        os.makedirs("data")
+
+    if "COPY solution/ /grader/solution/" in template_dict["dockerfile"]:
+        os.makedirs("solution")
+
 
 def generate_learner_version(
     filename_source: str,

dlai_grader/notebook.py

@@ -72,8 +72,8 @@ def keep_tagged_cells(
         filtered_cells = []
 
         for cell in notebook["cells"]:
-            if (not "tags" in cell["metadata"]) or (
-                not tag in cell["metadata"].get("tags")
+            if ("tags" not in cell["metadata"]) or (
+                tag not in cell["metadata"].get("tags")
             ):
                 continue
             filtered_cells.append(cell)
@@ -147,7 +147,7 @@ def get_named_cells(
     named_cells = {}
     for cell in notebook["cells"]:
         metadata = cell["metadata"]
-        if not "name" in metadata:
+        if "name" not in metadata:
             continue
         named_cells.update({metadata.get("name"): cell})
     return named_cells
@@ -169,12 +169,12 @@ def tag_code_cells(
 
     for cell in notebook["cells"]:
         if cell["cell_type"] == "code":
-            if not "tags" in cell["metadata"]:
+            if "tags" not in cell["metadata"]:
                 cell["metadata"]["tags"] = []
 
             tags = cell["metadata"]["tags"]
 
-            if not tag in tags:
+            if tag not in tags:
                 tags.append(tag)
                 cell["metadata"]["tags"] = tags
 
@@ -238,27 +238,31 @@ def add_metadata_code_cells_with_pattern(
 
 
 def add_metadata_code_cells_without_pattern(
-    notebook: NotebookNode, metadata: dict, regex_pattern: str = "^# GRADED "
+    notebook: NotebookNode,
+    metadata: dict,
+    match_pattern: str = "^# GRADED",
+    ignore_pattern: str = None,
 ) -> NotebookNode:
-    """Adds metadata to code cells of a notebook that don't match a regexp pattern.
+    """Adds metadata to code cells of a notebook that don't match a regexp pattern and aren't ignored by another pattern.
+
     Args:
         notebook (NotebookNode): Notebook to filter.
         metadata (dict): The metadata which should be a key-value pair.
-        regex_pattern (str, optional): Pattern to check. Defaults to "w[1-9]_unittest".
+        match_pattern (str, optional): Pattern to check which cells to add metadata to. Defaults to "^# GRADED ".
+        ignore_pattern (str, optional): Pattern to check which cells to ignore. If a cell matches this pattern, it will be skipped.
+
     Returns:
         NotebookNode: The notebook with the new metadata.
     """
-    filtered_cells = []
-
     for cell in notebook["cells"]:
-        if cell["cell_type"] == "code" and not re.search(regex_pattern, cell["source"]):
-            current_metadata = cell["metadata"]
-            current_metadata.update(metadata)
-            cell["metadata"] = current_metadata
-
-        filtered_cells.append(cell)
+        if cell["cell_type"] == "code":
+            if ignore_pattern and re.search(ignore_pattern, cell["source"]):
+                continue
 
-    notebook["cells"] = filtered_cells
+            if not re.search(match_pattern, cell["source"]):
+                current_metadata = cell.get("metadata", {})
+                current_metadata.update(metadata)
+                cell["metadata"] = current_metadata
 
     return notebook
 

dlai_grader/templates.py

@@ -1,77 +1,339 @@
+import sys
 from textwrap import dedent
-from typing import Dict
 
 
-def load_templates() -> Dict[str, str]:
-    specialization = input("Name of the specialization: ")
-    course = input("Number of the course: ")
-    week_or_module = input("Weeks or Modules?\n1 for weeks\n2 for modules: ")
-
-    if week_or_module == "1":
-        week = input("Number of the week: ")
-        module = None
-    elif week_or_module == "2":
-        module = input("Number of the module: ")
-        week = None
-    else:
-        print("invalid option selected")
-        exit(1)
+def generate_copy_assignment_script(
+    extra_file_required="n",
+    assignment_name="C1M2_Assignment.ipynb",
+    extra_file_name="foo.txt",
+):
+    """
+    Generate copy_assignment_to_submission.sh script with optional extra file copying.
 
-    unit_test_filename = input("Filename for unit tests (leave empty for unittests): ")
-    unit_test_filename = "unittests" if not unit_test_filename else unit_test_filename
-    version = input("Version of the grader (leave empty for version 1): ")
-    version = "1" if not version else version
+    Args:
+        extra_file_required (str): Include extra file copying if "y"
+        assignment_name (str): The name of the assignment notebook file
+        extra_file_name (str): The name of the extra file to copy (if required)
+
+    Returns:
+        str: The complete script content
+
+    """
+    # Common script header and initial variables
+    header = [
+        "#!/bin/bash",
+        "set -euo pipefail",
+        "",
+        "# each grader should modify Assignment and Submission file to fulfill the grader setting",
+        f"Assignment={assignment_name}",
+    ]
+
+    # Add extra file declaration if required
+    if extra_file_required == "y":
+        header.append(f"Extra_file={extra_file_name}")
+
+    # Common script variables
+    variables = [
+        "",
+        "SubmissionFile=submission.ipynb",
+        "SubmissionPath=/shared/submission",
+        "SharedDiskPath=/learner_workplace/$UserId/$CourseId/$LessonId",
+        "",
+        "# copy synced files (exam image typically sync all files in lesson folder)",
+        'echo "Copy learner submission from $SharedDiskPath/$Assignment to $SubmissionPath/$SubmissionFile"',
+        "cp $SharedDiskPath/$Assignment $SubmissionPath/$SubmissionFile",
+    ]
+
+    # Add extra file copying if required
+    extra_file_copy = []
+    if extra_file_required == "y":
+        extra_file_copy = [
+            'echo "Copy learner submission from $SharedDiskPath/$Extra_file to $SubmissionPath/$Extra_file"',
+            "cp $SharedDiskPath/$Extra_file $SubmissionPath/$Extra_file",
+        ]
+
+    # Combine all sections
+    content = header + variables + extra_file_copy
+
+    return "\n".join(content)
+
+
+def generate_entry_py(
+    non_notebook_grading="n",
+    extra_file_name="foo.txt",
+):
+    """
+    Generate entry.py with optional non-notebook grading capability.
 
-    dockerfile = """
-    FROM continuumio/miniconda3@sha256:d601a04ea48fd45e60808c7072243d33703d29434d2067816b7f26b0705d889a
+    Args:
+        non_notebook_grading (str): Include non-notebook grading if "y"
+        extra_file_name (str): Name of extra file to grade
 
-    RUN apk update && apk add libstdc++
+    Returns:
+        str: The complete entry.py content
 
-    COPY requirements.txt .
+    """
+    # Common imports for both versions
+    imports = [
+        "from dlai_grader.config import Config, get_part_id",
+        "from dlai_grader.compiler import compile_partial_module",
+        "from dlai_grader.io import read_notebook, copy_submission_to_workdir, send_feedback",
+        "from dlai_grader.notebook import keep_tagged_cells",
+        "from dlai_grader.grading import (",
+        "    compute_grading_score,",
+        "    graded_obj_missing,",
+        "    LearnerSubmission,",
+        ")",
+        "from grader import handle_part_id",
+        "",
+    ]
+
+    # Notebook grading function (common to both versions)
+    notebook_grading_func = [
+        "",
+        "def notebook_grading(config, compile_solution=False):",
+        "    try:",
+        "        nb = read_notebook(config.submission_file_path)",
+        "    except Exception as e:",
+        '        msg = f"There was a problem reading your notebook. Details:\\n{e!s}"',
+        "        send_feedback(0.0, msg, err=True)",
+        "",
+        "    transformations = [keep_tagged_cells()]",
+        "    for t in transformations:",
+        "        nb = t(nb)",
+        "",
+        "    try:",
+        '        learner_mod = compile_partial_module(nb, "learner_mod", verbose=False)',
+        "    except Exception as e:",
+        '        msg = f"There was a problem compiling the code from your notebook, please check that you saved before submitting. Details:\\n{e!s}"',
+        "        send_feedback(0.0, msg, err=True)",
+        "",
+        "    solution_mod = None",
+        "    if compile_solution:",
+        "        solution_nb = read_notebook(config.solution_file_path)",
+        "        for t in transformations:",
+        "            solution_nb = t(solution_nb)",
+        "        solution_mod = compile_partial_module(",
+        '            solution_nb, "solution_mod", verbose=False',
+        "        )",
+        "",
+        "    return learner_mod, solution_mod",
+        "",
+    ]
+
+    # Non-notebook grading function (only for version with non_notebook_grading)
+    non_notebook_grading_func = [
+        "",
+        "def non_notebook_grading(config):",
+        "    try:",
+        '        with open(config.submission_file_path, "r") as file:',
+        "            contents = file.read()",
+        "    except Exception as e:",
+        '        msg = f"There was an error reading your submission. Details:\\n{e!s}"',
+        "        send_feedback(0.0, msg, err=True)",
+        "",
+        "    return LearnerSubmission(submission=contents)",
+        "",
+    ]
+
+    # Main function for version without non-notebook grading
+    main_func_simple = [
+        "def main() -> None:",
+        "    copy_submission_to_workdir()",
+        "",
+        "    part_id = get_part_id()",
+        "",
+        "    c = Config()",
+        "",
+        "    learner_mod, _ = notebook_grading(c)",
+        "",
+        "    g_func = handle_part_id(part_id)(learner_mod)",
+        "",
+        "    try:",
+        "        cases = g_func()",
+        "    except Exception as e:",
+        '        msg = f"There was an error grading your submission. Details:\\n{e!s}"',
+        "        send_feedback(0.0, msg, err=True)",
+        "",
+        "    if graded_obj_missing(cases):",
+        '        msg = "Object required for grading not found. If you haven\'t completed the exercise this might be expected. Otherwise, check your solution as grader omits cells that throw errors."',
+        "        send_feedback(0.0, msg, err=True)",
+        "",
+        "    score, feedback = compute_grading_score(cases)",
+        "    send_feedback(score, feedback)",
+        "",
+    ]
+
+    # Main function for version with non-notebook grading
+    main_func_with_non_notebook = [
+        "def main() -> None:",
+        "    copy_submission_to_workdir()",
+        "",
+        "    part_id = get_part_id()",
+        "",
+        "    match part_id:",
+        '        case "123":',
+        f'            c = Config(submission_file="{extra_file_name}")',
+        "            learner_mod = non_notebook_grading(c)",
+        "        case _:",
+        "            c = Config()",
+        "            learner_mod, _ = notebook_grading(c)",
+        "",
+        "    g_func = handle_part_id(part_id)(learner_mod)",
+        "",
+        "    try:",
+        "        cases = g_func()",
+        "    except Exception as e:",
+        '        msg = f"There was an error grading your submission. Details:\\n{e!s}"',
+        "        send_feedback(0.0, msg, err=True)",
+        "",
+        "    if graded_obj_missing(cases):",
+        '        msg = "Object required for grading not found. If you haven\'t completed the exercise this might be expected. Otherwise, check your solution as grader omits cells that throw errors."',
+        "        send_feedback(0.0, msg, err=True)",
+        "",
+        "    score, feedback = compute_grading_score(cases)",
+        "    send_feedback(score, feedback)",
+        "",
+    ]
+
+    # Common script entry point
+    entry_point = [
+        'if __name__ == "__main__":',
+        "    main()",
+        "",
+    ]
+
+    # Combine all sections based on configuration
+    content = imports + notebook_grading_func
+
+    if non_notebook_grading == "y":
+        content.extend(non_notebook_grading_func)
+        content.extend(main_func_with_non_notebook)
+    else:
+        content.extend(main_func_simple)
 
-    RUN pip install -r requirements.txt && \
-    rm requirements.txt
+    content.extend(entry_point)
 
-    RUN mkdir /grader && \ 
-    mkdir /grader/submission
+    return "\n".join(content)
 
-    COPY .conf /grader/.conf
-    COPY data/ /grader/data/
-    COPY solution/ /grader/solution/
-    COPY entry.py /grader/entry.py
-    COPY grader.py /grader/grader.py
 
-    RUN chmod a+rwx /grader/
+def generate_dockerfile(data_dir_required="n", sol_dir_required="n"):
+    """
+    Generate a Dockerfile with optional data and solution directories.
 
-    WORKDIR /grader/
+    Args:
+        data_dir_required (str): Include data directory if "y"
+        sol_dir_required (str): Include solution directory if "y"
+
+    Returns:
+        str: The complete Dockerfile content
 
-    ENTRYPOINT ["python", "entry.py"]
     """
+    base_content = [
+        "FROM continuumio/miniconda3@sha256:d601a04ea48fd45e60808c7072243d33703d29434d2067816b7f26b0705d889a",
+        "",
+        "RUN apk update && apk add libstdc++",
+        "",
+        "COPY requirements.txt .",
+        "",
+        "RUN pip install -r requirements.txt && rm requirements.txt",
+        "",
+        "RUN mkdir /grader && \\ \nmkdir /grader/submission",
+        "",
+        "COPY .conf /grader/.conf",
+    ]
+
+    # Add optional file copies based on config
+    if data_dir_required == "y":
+        base_content.append("COPY data/ /grader/data/")
+
+    if sol_dir_required == "y":
+        base_content.append("COPY solution/ /grader/solution/")
+
+    # Add final common parts
+    base_content.extend(
+        [
+            "COPY entry.py /grader/entry.py",
+            "COPY grader.py /grader/grader.py",
+            "",
+            "RUN chmod a+rwx /grader/",
+            "",
+            "WORKDIR /grader/",
+            "",
+            'ENTRYPOINT ["python", "entry.py"]',
+        ]
+    )
 
-    if week:
-        W_OR_M = "W"
-        W_OR_M_num = week
+    return "\n".join(base_content)
 
-    if module:
-        W_OR_M = "M"
-        W_OR_M_num = module
+
+def load_templates() -> dict[str, str]:
+    specialization = input("Name of the specialization: ")
+    course = input("Number of the course: ")
+    module = input("Number of the module: ")
+
+    unit_test_filename = input("Filename for unit tests (leave empty for unittests): ")
+    unit_test_filename = unit_test_filename if unit_test_filename else "unittests"
+    version = input("Version of the grader (leave empty for version 1): ")
+    version = version if version else "1"
+    data_dir_required = input("Do you require a data dir? y/n (leave empty for n): ")
+    data_dir_required = data_dir_required if data_dir_required else "n"
+
+    if data_dir_required not in ["y", "n"]:
+        print("invalid option selected")
+        sys.exit(1)
+
+    sol_dir_required = input(
+        "Do you require a solution file? y/n (leave empty for n): "
+    )
+    sol_dir_required = sol_dir_required if sol_dir_required else "n"
+    if sol_dir_required not in ["y", "n"]:
+        print("invalid option selected")
+        sys.exit(1)
+
+    non_notebook_grading = input(
+        "Will you grade a file different from a notebook? y/n (leave empty for n): ",
+    )
+    non_notebook_grading = non_notebook_grading if non_notebook_grading else "n"
+    if non_notebook_grading not in ["y", "n"]:
+        print("invalid option selected")
+        sys.exit(1)
+
+    extra_file_name = ""
+    if non_notebook_grading == "y":
+        extra_file_name = input(
+            "Name of the extra file to grade: ",
+        )
+
+    dockerfile = generate_dockerfile(
+        data_dir_required=data_dir_required,
+        sol_dir_required=sol_dir_required,
+    )
 
     conf = f"""
-    ASSIGNMENT_NAME=C{course}{W_OR_M}{W_OR_M_num}_Assignment
+    ASSIGNMENT_NAME=C{course}M{module}_Assignment
     UNIT_TESTS_NAME={unit_test_filename}
-    IMAGE_NAME={specialization}c{course}{W_OR_M.lower()}{W_OR_M_num}-grader
+    IMAGE_NAME={specialization}c{course}m{module}-grader
     GRADER_VERSION={version}
     TAG_ID=V$(GRADER_VERSION)
     SUB_DIR=mount
     MEMORY_LIMIT=4096
     """
 
+    assignment_name = f"C{course}M{module}_Assignment.ipynb"
+
+    copy_assignment_to_submission_sh = generate_copy_assignment_script(
+        extra_file_required=non_notebook_grading,
+        assignment_name=assignment_name,
+        extra_file_name=extra_file_name,
+    )
+
     makefile = """
-	.PHONY: learner build entry submit-solution upgrade test grade mem zip clean upload move-zip move-learner tag undeletable uneditable versioning upgrade sync
+	.PHONY: sync learner build debug-unsafe debug-safe grade versioning tag undeletable uneditable init upgrade coursera zip
 
 	include .conf
 
-	PARTIDS = ""
+	PARTIDS = 123 456
 	OS := $(shell uname)
 
 	sync:
@@ -81,15 +343,19 @@ def load_templates() -> Dict[str, str]:
 
 	learner:
 		dlai_grader --learner --output_notebook=./learner/$(ASSIGNMENT_NAME).ipynb
+		rsync -a --exclude="submission.ipynb" --exclude="__pycache__" --exclude=".mypy_cache" ./mount/ ./learner/
 
 	build:
 		docker build -t $(IMAGE_NAME):$(TAG_ID) .
 
-	debug:
-		docker run -it --rm --mount type=bind,source=$(PWD)/mount,target=/shared/submission --mount type=bind,source=$(PWD),target=/grader/ --entrypoint ash $(IMAGE_NAME):$(TAG_ID)
+	debug-unsafe:
+		docker run -it --rm --mount type=bind,source=$(PWD)/mount,target=/shared/submission --mount type=bind,source=$(PWD),target=/grader/ --env-file $(PWD)/.env --entrypoint ash $(IMAGE_NAME):$(TAG_ID)
+
+	debug-safe:
+		docker run -it --rm --mount type=bind,source=$(PWD)/mount,target=/shared/submission --env-file $(PWD)/.env --entrypoint ash $(IMAGE_NAME):$(TAG_ID)
 
-	submit-solution:
-		cp solution/solution.ipynb mount/submission.ipynb
+	grade:
+		docker run -it --rm --mount type=bind,source=$(PWD)/mount,target=/shared/submission --env-file $(PWD)/.env --entrypoint ash $(IMAGE_NAME):$(TAG_ID) -c 'for partId in $(PARTIDS); do export partId=$$partId; echo "Processing part $$partId"; python entry.py; done'
 
 	versioning:
 		dlai_grader --versioning
@@ -103,160 +369,70 @@ def load_templates() -> Dict[str, str]:
 	uneditable:
 		dlai_grader --uneditable
 
+	init:
+		dlai_grader --versioning
+		dlai_grader --tag
+		dlai_grader --undeletable
+		dlai_grader --uneditable
+
 	upgrade:
 		dlai_grader --upgrade
 
-	test:
-		docker run -it --rm --mount type=bind,source=$(PWD)/mount,target=/shared/submission --mount type=bind,source=$(PWD),target=/grader/ --entrypoint pytest $(IMAGE_NAME):$(TAG_ID)
-
-	grade:
-		dlai_grader --grade --partids=$(PARTIDS) --docker=$(IMAGE_NAME):$(TAG_ID) --memory=$(MEMORY_LIMIT) --submission=$(SUB_DIR)
-
-	mem:
-		memthis $(PARTIDS)
+	coursera:
+		dlai_grader --grade --partids="$(PARTIDS)" --docker=$(IMAGE_NAME):$(TAG_ID) --memory=$(MEMORY_LIMIT) --submission=$(SUB_DIR)
 
 	zip:
 		zip -r $(IMAGE_NAME)$(TAG_ID).zip .
 
-	clean:
-		find . -maxdepth 1 -type f -name "*.zip" -exec rm {} +
-		docker rm $$(docker ps -qa --no-trunc --filter "status=exited")
-		docker rmi $$(docker images --filter "dangling=true" -q --no-trunc)
-
-	upload:
-		coursera_autograder --timeout 1800 upload --grader-memory-limit $(MEMORY_LIMIT) --grading-timeout 1800 $(IMAGE_NAME)$(TAG_ID).zip $(COURSE_ID) $(ITEM_ID) $(PART_ID)
-
 	"""
 
     grader_py = """
     from types import ModuleType, FunctionType
-    from typing import Dict, List, Optional
     from dlai_grader.grading import test_case, object_to_grade
     from dlai_grader.types import grading_function, grading_wrapper, learner_submission
 
 
     def part_1(
-        learner_mod: learner_submission, solution_mod: Optional[ModuleType]
+        learner_mod: learner_submission,
+        solution_mod: ModuleType | None = None,
     ) -> grading_function:
         @object_to_grade(learner_mod, "learner_func")
-        def g(learner_func: FunctionType) -> List[test_case]:
+        def g(learner_func: FunctionType) -> list[test_case]:
+
+            cases: list[test_case] = []
 
             t = test_case()
             if not isinstance(learner_func, FunctionType):
-                t.failed = True
+                t.fail()
                 t.msg = "learner_func has incorrect type"
                 t.want = FunctionType
                 t.got = type(learner_func)
                 return [t]
 
-            cases: List[test_case] = []
-
             return cases
 
         return g
 
 
     def handle_part_id(part_id: str) -> grading_wrapper:
-        grader_dict: Dict[str, grading_wrapper] = {
+        grader_dict: dict[str, grading_wrapper] = {
             "": part_1,
         }
         return grader_dict[part_id]
     """
 
-    entry_py = """
-    from dlai_grader.config import Config
-    from dlai_grader.compiler import compile_partial_module
-    from dlai_grader.io import read_notebook, copy_submission_to_workdir, send_feedback
-
-    from dlai_grader.notebook import (
-        notebook_to_script,
-        keep_tagged_cells,
-        notebook_is_up_to_date,
-        notebook_version,
-        cut_notebook,
-        partial_grading_enabled,
+    entry_py = generate_entry_py(
+        non_notebook_grading=non_notebook_grading,
+        extra_file_name=extra_file_name,
     )
-    from dlai_grader.grading import compute_grading_score, graded_obj_missing
-    from grader import handle_part_id
-
-
-    def main() -> None:
-        c = Config()
-
-        copy_submission_to_workdir()
-
-        try:
-            nb = read_notebook(c.submission_file_path)
-        except Exception as e:
-            send_feedback(
-                0.0,
-                f"There was a problem reading your notebook. Details:\\n{str(e)}",
-                err=True,
-            )
-
-        if not notebook_is_up_to_date(nb):
-            msg = f"You are submitting a version of the assignment that is behind the latest version.\\nThe latest version is {c.latest_version} and you are on version {notebook_version(nb)}."
-
-            send_feedback(0.0, msg)
-
-        transformations = [cut_notebook(), keep_tagged_cells()]
-
-        for t in transformations:
-            nb = t(nb)
-
-        try:
-            learner_mod = compile_partial_module(nb, "learner_mod", verbose=False)
-        except Exception as e:
-            send_feedback(
-                0.0,
-                f"There was a problem compiling the code from your notebook, please check that you saved before submitting. Details:\\n{str(e)}",
-                err=True,
-            )
-
-        solution_nb = read_notebook(c.solution_file_path)
-        
-        for t in transformations:
-            solution_nb = t(solution_nb)
-
-        solution_mod = compile_partial_module(solution_nb, "solution_mod", verbose=False)
-
-        g_func = handle_part_id(c.part_id)(learner_mod, solution_mod)
-
-        try:
-            cases = g_func()
-        except Exception as e:
-            send_feedback(
-                0.0,
-                f"There was an error grading your submission. Details:\\n{str(e)}",
-                err=True,
-            )
-
-        if graded_obj_missing(cases):
-            additional_msg = ""
-            if partial_grading_enabled(nb):
-                additional_msg = "The # grade-up-to-here comment in the notebook might be causing the problem."
-
-            send_feedback(
-                0.0,
-                f"Object required for grading not found. If you haven't completed the exercise this is expected. Otherwise, check your solution as grader omits cells that throw errors.\\n{additional_msg}",
-                err=True,
-            )
-
-        score, feedback = compute_grading_score(cases)
-
-        send_feedback(score, feedback)
-
-
-    if __name__ == "__main__":
-        main()
-    """
 
     template_dict = {
-        "dockerfile": dedent(dockerfile[1:]),
+        "dockerfile": dedent(dockerfile),
         "makefile": dedent(makefile[1:]),
         "conf": dedent(conf[1:]),
         "grader_py": dedent(grader_py[1:]),
-        "entry_py": dedent(entry_py[1:]),
+        "entry_py": dedent(entry_py),
+        "copy_assignment_to_submission_sh": dedent(copy_assignment_to_submission_sh),
     }
 
     return template_dict

dlai_grader/types.py

@@ -1,7 +1,8 @@
+from collections.abc import Callable
 from types import ModuleType
-from typing import Any, Callable, List, Optional, Union
-from .grading import test_case, LearnerSubmission
 
-grading_function = Callable[[Any], List[test_case]]
-learner_submission = Union[ModuleType, LearnerSubmission]
-grading_wrapper = Callable[[learner_submission, Optional[ModuleType]], grading_function]
+from .grading import LearnerSubmission, test_case
+
+grading_function = Callable[..., list[test_case]]
+learner_submission = ModuleType | LearnerSubmission
+grading_wrapper = Callable[[learner_submission, ModuleType | None], grading_function]

{dlai_grader-1.22.0.dist-info → dlai_grader-2.0b1.dist-info}/METADATA

@@ -1,27 +1,23 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: dlai-grader
-Version: 1.22.0
+Version: 2.0b1
 Summary: Grading utilities for DLAI courses
 Home-page: https://github.com/https-deeplearning-ai/grader
 Author: Andres Zarta
-Author-email: andrezb5@gmail.com
-License: MIT License
+Author-email: Andres Zarta <andrezb5@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/https-deeplearning-ai/grader
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: nbformat>=5.1.3
 Requires-Dist: jupytext>=1.13.0
 Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
 Dynamic: home-page
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: summary
+Dynamic: license-file
 
 # grader
 Automatic grading for DLAI courses. Designed to be compatible with Coursera's grading requirements.

dlai_grader-2.0b1.dist-info/RECORD

@@ -0,0 +1,16 @@
+dlai_grader/__init__.py,sha256=V0DW6eFVqfyWdxFvJavFxD2QV63rZCpT400IzY1QBkk,210
+dlai_grader/cli.py,sha256=NIwboE-AFn1LXOFmF4O70Ow0fkRxgclG_eMwmWiua38,4917
+dlai_grader/compiler.py,sha256=elbHNUCqBCoOOoNmMRXbgeNL0nt0RM57eZi0-6AqycA,3036
+dlai_grader/config.py,sha256=DokK1tVF_r7v0p9tWpBN-7lOAlPmHSpFXDZiI8cGw7s,1821
+dlai_grader/grading.py,sha256=BMIoZ_loQDuNCEk1Dj3on4IWz-FGgIbnhbDyk8HmQ7c,5041
+dlai_grader/io.py,sha256=TEp5R8014EL9e-_RID5qp9INOujAGi7KLuy-SWWsPkM,8654
+dlai_grader/notebook.py,sha256=MgxZFuetTXwwZ-HXSB5ItLVD_9LP45E0xHAngS0g4EU,12101
+dlai_grader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dlai_grader/templates.py,sha256=SEMv4KFlq_2jy4UORMzHStOOex9P6LXr48Ie-r1JZcc,14627
+dlai_grader/types.py,sha256=5uiFaF3aDn-vjxTp9ec-ND-PRqeeV2_NfPHS2ngGsRo,306
+dlai_grader-2.0b1.dist-info/licenses/LICENSE,sha256=a_kch_UqdJPtyxk35QJr9O84K_koPixqWPYW9On4-io,1072
+dlai_grader-2.0b1.dist-info/METADATA,sha256=0-7wdm6Otf4nHWASbjMHMBt8ruXvl3RrDakgAVPCMlA,8776
+dlai_grader-2.0b1.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+dlai_grader-2.0b1.dist-info/entry_points.txt,sha256=4OcSAUIluONXa3ymViQ7CBQ2Lk52nb6xZnfph1rlMnk,71
+dlai_grader-2.0b1.dist-info/top_level.txt,sha256=4YKtA3ztisFtx_g4hsGivy3J2NHnXxFziIMqawC8HWg,12
+dlai_grader-2.0b1.dist-info/RECORD,,

{dlai_grader-1.22.0.dist-info → dlai_grader-2.0b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (78.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dlai_grader-1.22.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-dlai_grader/__init__.py,sha256=FbFOZrZiR0vT6s9LdqnU3nNiuTZs2LbhLaF4OCJrDCY,211
-dlai_grader/cli.py,sha256=NIwboE-AFn1LXOFmF4O70Ow0fkRxgclG_eMwmWiua38,4917
-dlai_grader/compiler.py,sha256=elbHNUCqBCoOOoNmMRXbgeNL0nt0RM57eZi0-6AqycA,3036
-dlai_grader/config.py,sha256=HQ3dzaFpRswIA_7EC8XdP8DdJH-XePsbMQMHG8Esblc,1638
-dlai_grader/grading.py,sha256=Gmft9b7M8At_y_WZDatYdW6tinZMfqQoT7bDXp6uz2I,4606
-dlai_grader/io.py,sha256=TB9d01AK5FIbFUQwM8AqOOfuMWzjzrit98i3MhK5AqU,8234
-dlai_grader/notebook.py,sha256=noMU6DzPVylSjkHmSBUcmquVvAz4JigbRtbQrVYJdic,11830
-dlai_grader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dlai_grader/templates.py,sha256=JDDPoFm13pqRIOwSpt5kXXtMUM7jOv2Uyz1ap8KWu4I,7850
-dlai_grader/types.py,sha256=_IIVbYL9cMmwA6in0aI5fEWCIaAMNcQbxG64X1P1CkE,335
-dlai_grader-1.22.0.dist-info/LICENSE,sha256=a_kch_UqdJPtyxk35QJr9O84K_koPixqWPYW9On4-io,1072
-dlai_grader-1.22.0.dist-info/METADATA,sha256=GWPfw91xdTsJfWcjOgcGmtmZ2bhM60KJAPHnmQc6oUQ,8807
-dlai_grader-1.22.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-dlai_grader-1.22.0.dist-info/entry_points.txt,sha256=4OcSAUIluONXa3ymViQ7CBQ2Lk52nb6xZnfph1rlMnk,71
-dlai_grader-1.22.0.dist-info/top_level.txt,sha256=4YKtA3ztisFtx_g4hsGivy3J2NHnXxFziIMqawC8HWg,12
-dlai_grader-1.22.0.dist-info/RECORD,,