dlai-grader 1.22.2__py3-none-any.whl → 2.2.0__py3-none-any.whl

dlai_grader/templates.py

@@ -1,262 +1,319 @@
+import sys
+import textwrap
 from textwrap import dedent
-from typing import Dict
+import shutil
+import os
+from pathlib import Path
 
 
-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)
-
-    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
-
-    dockerfile = """
-    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 && \ 
-    mkdir /grader/submission
-
-    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/
-
-    WORKDIR /grader/
-
-    ENTRYPOINT ["python", "entry.py"]
+def generate_copy_assignment_script(
+    extra_file_required="n",
+    assignment_name="C1M2_Assignment.ipynb",
+    extra_file_name="foo.txt",
+):
     """
+    Copy the appropriate copy_assignment_to_submission.sh script from templates depending on whether an extra file is required.
 
-    if week:
-        W_OR_M = "W"
-        W_OR_M_num = week
+    Template files should be named:
+        extrafile_n   (no extra file)
+        extrafile_y   (with extra file)
 
-    if module:
-        W_OR_M = "M"
-        W_OR_M_num = module
+    Returns:
+        str: The final shell script contents after variable substitution.
 
-    conf = f"""
-    ASSIGNMENT_NAME=C{course}{W_OR_M}{W_OR_M_num}_Assignment
-    UNIT_TESTS_NAME={unit_test_filename}
-    IMAGE_NAME={specialization}c{course}{W_OR_M.lower()}{W_OR_M_num}-grader
-    GRADER_VERSION={version}
-    TAG_ID=V$(GRADER_VERSION)
-    SUB_DIR=mount
-    MEMORY_LIMIT=4096
     """
+    if extra_file_required not in ("y", "n"):
+        raise ValueError(f"Invalid extra_file_required value: {extra_file_required!r}")
 
-    makefile = """
-	.PHONY: learner build entry submit-solution upgrade test grade mem zip clean upload move-zip move-learner tag undeletable uneditable versioning upgrade sync
+    # Define template name pattern
+    template_name = f"extrafile_{extra_file_required}"
 
-	include .conf
+    # Paths
+    base_dir = Path(__file__).parent
+    src = base_dir / "templates" / "copy_assignment_sh" / template_name
+    dst = Path("copy_assignment_to_submission.sh")
 
-	PARTIDS = ""
-	OS := $(shell uname)
+    # Validate existence
+    if not src.exists():
+        raise FileNotFoundError(f"Template not found: {src}")
 
-	sync:
-		cp mount/submission.ipynb ../$(ASSIGNMENT_NAME)_Solution.ipynb
-		cp learner/$(ASSIGNMENT_NAME).ipynb ../$(ASSIGNMENT_NAME).ipynb
-		cp mount/$(UNIT_TESTS_NAME).py ../$(UNIT_TESTS_NAME).py
+    # Read and substitute placeholders
+    content = src.read_text(encoding="utf-8")
+    content = content.replace("{{ASSIGNMENT_NAME}}", assignment_name).replace(
+        "{{EXTRA_FILE_NAME}}", extra_file_name
+    )
 
-	learner:
-		dlai_grader --learner --output_notebook=./learner/$(ASSIGNMENT_NAME).ipynb
+    # Write output
+    dst.write_text(content, encoding="utf-8")
+    dst.chmod(0o755)  # make executable
+    return content
 
-	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)
+def copy_entry_script(
+    sol_dir_required: str,
+    non_notebook_grading: str,
+    extra_file_name="foo.txt",
+) -> str:
+    # Validate inputs
+    if sol_dir_required not in ("y", "n"):
+        raise ValueError(f"Invalid sol_dir_required value: {sol_dir_required!r}")
+    if non_notebook_grading not in ("y", "n"):
+        raise ValueError(
+            f"Invalid non_notebook_grading value: {non_notebook_grading!r}"
+        )
 
-	submit-solution:
-		cp solution/solution.ipynb mount/submission.ipynb
+    template_name = f"solution_{sol_dir_required}_file_{non_notebook_grading}.py"
 
-	versioning:
-		dlai_grader --versioning
+    base_dir = Path(__file__).parent
+    src = base_dir / "templates" / "entry_py" / template_name
+    content = src.read_text(encoding="utf-8")
+    content = content.replace("{{EXTRA_FILE_NAME}}", extra_file_name)
+    dst = Path("entry.py")
 
-	tag:
-		dlai_grader --tag
+    if not src.exists():
+        raise FileNotFoundError(f"Template not found: {src}")
 
-	undeletable:
-		dlai_grader --undeletable
+    # shutil.copy(src, dst)
+    return content
 
-	uneditable:
-		dlai_grader --uneditable
 
-	upgrade:
-		dlai_grader --upgrade
+def generate_dockerfile(data_dir_required="n", sol_dir_required="n"):
+    """
+    Generate a Dockerfile with optional data and solution directories.
 
-	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)
+    Args:
+        data_dir_required (str): Include data directory if "y"
+        sol_dir_required (str): Include solution directory if "y"
 
-	grade:
-		dlai_grader --grade --partids=$(PARTIDS) --docker=$(IMAGE_NAME):$(TAG_ID) --memory=$(MEMORY_LIMIT) --submission=$(SUB_DIR)
+    """
+    # Validate inputs
+    if data_dir_required not in ("y", "n"):
+        raise ValueError(f"Invalid data_dir_required value: {data_dir_required!r}")
+    if sol_dir_required not in ("y", "n"):
+        raise ValueError(f"Invalid sol_dir_required value: {sol_dir_required!r}")
 
-	mem:
-		memthis $(PARTIDS)
+    template_name = f"data_{data_dir_required}_solution_{sol_dir_required}"
 
-	zip:
-		zip -r $(IMAGE_NAME)$(TAG_ID).zip .
+    # Define paths
+    base_dir = Path(__file__).parent
+    src = base_dir / "templates" / "dockerfile" / template_name
+    dst = Path("Dockerfile")
 
-	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)
+    # Ensure the source exists
+    if not src.exists():
+        raise FileNotFoundError(f"Template not found: {src}")
 
-	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)
+    # Copy template to current directory
+    # shutil.copy(src, dst)
 
-	"""
+    # Return the Dockerfile contents
+    return src.read_text(encoding="utf-8")
 
-    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 copy_makefile() -> str:
+    base_dir = Path(__file__).parent
+    src = base_dir / "templates" / "Makefile"
+    # content = src.read_text(encoding="utf-8")
+    # content = content.replace("{{HARD_MEMORY}}", hard_memory)
+    # content = content.replace("{{CPUS}}", cpus)
+    # content = content.replace("{{SOFT_MEMORY}}", soft_memory)
+    dst = Path("Makefile")
 
-    def part_1(
-        learner_mod: learner_submission, solution_mod: Optional[ModuleType] = None
-    ) -> grading_function:
-        @object_to_grade(learner_mod, "learner_func")
-        def g(learner_func: FunctionType) -> List[test_case]:
+    if not src.exists():
+        raise FileNotFoundError(f"Template not found: {src}")
 
-            t = test_case()
-            if not isinstance(learner_func, FunctionType):
-                t.failed = True
-                t.msg = "learner_func has incorrect type"
-                t.want = FunctionType
-                t.got = type(learner_func)
-                return [t]
+    # shutil.copy(src, dst)
+    return src.read_text(encoding="utf-8")
 
-            cases: List[test_case] = []
 
-            return cases
+def copy_grader_py() -> str:
+    base_dir = Path(__file__).parent
+    src = base_dir / "templates" / "grader.py"
+    dst = Path("grader.py")
 
-        return g
+    if not src.exists():
+        raise FileNotFoundError(f"Template not found: {src}")
 
+    # shutil.copy(src, dst)
+    return src.read_text(encoding="utf-8")
 
-    def handle_part_id(part_id: 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,
-    )
-    from dlai_grader.grading import compute_grading_score, graded_obj_missing
-    from grader import handle_part_id
+def copy_submission_ipynb() -> str:
+    base_dir = Path(__file__).parent
+    src = base_dir / "templates" / "submission.ipynb"
 
+    if not src.exists():
+        raise FileNotFoundError(f"Template not found: {src}")
 
-    def main() -> None:
-        c = Config()
+    # shutil.copy(src, dst)
+    return src.read_text(encoding="utf-8")
 
-        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()]
+def load_templates() -> dict[str, str]:
+    specialization = input("Name of the specialization: ")
+    course = input("Number of the course: ")
+    module = input("Number of the module: ")
 
-        for t in transformations:
-            nb = t(nb)
+    grader_mvp = input(
+        "Use minimum grader (no extra config)? y/n (leave empty for n): ",
+    )
 
-        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,
+    grader_mvp = grader_mvp if grader_mvp else "n"
+    if grader_mvp not in ["y", "n"]:
+        print("invalid option selected")
+        sys.exit(1)
+
+    if grader_mvp == "n":
+        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 = "1"
+
+        data_dir_required = ""
+        while data_dir_required not in ["y", "n"]:
+            data_dir_required = input(
+                "Do you require a data dir? y/n (leave empty for n): ",
+            )
+            if data_dir_required == "":
+                data_dir_required = "n"
+            # data_dir_required = data_dir_required if data_dir_required else "n"
+
+        sol_dir_required = ""
+        while sol_dir_required not in ["y", "n"]:
+            sol_dir_required = input(
+                "Do you require a solution file? y/n (leave empty for n): ",
             )
+            if sol_dir_required == "":
+                sol_dir_required = "n"
 
-        solution_nb = read_notebook(c.solution_file_path)
-        
-        for t in transformations:
-            solution_nb = t(solution_nb)
+        non_notebook_grading = ""
+        while non_notebook_grading not in ["y", "n"]:
+            non_notebook_grading = input(
+                "Will you grade a file different from a notebook? y/n (leave empty for n): ",
+            )
+            if non_notebook_grading == "":
+                non_notebook_grading = "n"
 
-        solution_mod = compile_partial_module(solution_nb, "solution_mod", verbose=False)
+        extra_file_name = ""
+        if non_notebook_grading == "y":
+            extra_file_name = input(
+                "Name of the extra file to grade: ",
+            )
 
-        g_func = handle_part_id(c.part_id)(learner_mod)
+        cpus = ""
+        while cpus not in ["0.25", "0.5", "0.75", "1"]:
+            cpus = input("CPU Units (leave empty for 0.25): ")
+            if cpus == "":
+                cpus = "0.25"
+
+            if cpus not in ["0.25", "0.5", "0.75", "1"]:
+                print(f"Options are: {['0.25', '0.5', '0.75', '1']}")
+
+        soft_memory = ""
+        soft_memory_options = [
+            "512m",
+            "768m",
+            "1024m",
+            "2048m",
+            "4096m",
+            "8192m",
+            "1g",
+            "2g",
+            "4g",
+            "8g",
+        ]
+        while soft_memory not in soft_memory_options:
+            soft_memory = input("Memory Reservation (leave empty for 512m): ")
+            if soft_memory == "":
+                soft_memory = "512m"
+
+            if soft_memory not in soft_memory_options:
+                print(f"Options are: {soft_memory_options}")
+
+        hard_memory = ""
+        hard_memory_options = [
+            "1024m",
+            "2048m",
+            "4096m",
+            "8192m",
+            "15000m",
+            "1g",
+            "2g",
+            "4g",
+            "8g",
+            "15g",
+        ]
+        while hard_memory not in hard_memory_options:
+            hard_memory = input("Memory Limit (leave empty for 1g): ")
+            if hard_memory == "":
+                hard_memory = "1g"
+
+            if hard_memory not in hard_memory_options:
+                print(f"Options are: {hard_memory_options}")
+
+    if grader_mvp == "y":
+        unit_test_filename = "unittests"
+        version = "1"
+        data_dir_required = "n"
+        sol_dir_required = "n"
+        non_notebook_grading = "n"
+        extra_file_name = ""
+        cpus = "0.25"
+        soft_memory = "512m"
+        hard_memory = "1g"
+
+    dockerfile = generate_dockerfile(
+        data_dir_required=data_dir_required,
+        sol_dir_required=sol_dir_required,
+    )
 
-        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,
-            )
+    conf = f"""
+    ASSIGNMENT_NAME=C{course}M{module}_Assignment
+    UNIT_TESTS_NAME={unit_test_filename}
+    IMAGE_NAME={specialization}c{course}m{module}-grader
+    GRADER_VERSION={version}
+    TAG_ID=V$(GRADER_VERSION)
+    SUB_DIR=mount
+    MEMORY_LIMIT=4096
+    CPUS={cpus}
+    SOFT_MEMORY={soft_memory}
+    HARD_MEMORY={hard_memory}
+    """
 
-        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."
+    assignment_name = f"C{course}M{module}_Assignment.ipynb"
 
-            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,
-            )
+    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,
+    )
 
-        score, feedback = compute_grading_score(cases)
+    makefile = copy_makefile()
 
-        send_feedback(score, feedback)
+    grader_py = copy_grader_py()
 
+    submission_ipynb = copy_submission_ipynb()
 
-    if __name__ == "__main__":
-        main()
-    """
+    entry_py = copy_entry_script(
+        sol_dir_required=sol_dir_required,
+        non_notebook_grading=non_notebook_grading,
+        extra_file_name=extra_file_name,
+    )
 
     template_dict = {
-        "dockerfile": dedent(dockerfile[1:]),
-        "makefile": dedent(makefile[1:]),
+        "dockerfile": dedent(dockerfile),
+        "makefile": dedent(makefile),
         "conf": dedent(conf[1:]),
-        "grader_py": dedent(grader_py[1:]),
-        "entry_py": dedent(entry_py[1:]),
+        "grader_py": dedent(grader_py),
+        "entry_py": dedent(entry_py),
+        "extra_file_name": extra_file_name,
+        "submission_ipynb": submission_ipynb,
+        # "copy_assignment_to_submission_sh": dedent(copy_assignment_to_submission_sh),
     }
 
+    if extra_file_name:
+        template_dict.update({"extra_file_name": extra_file_name})
+
     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.2.dist-info → dlai_grader-2.2.0.dist-info}/METADATA

@@ -1,18 +1,23 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: dlai-grader
-Version: 1.22.2
+Version: 2.2.0
 Summary: Grading utilities for DLAI courses
 Home-page: https://github.com/https-deeplearning-ai/grader
 Author: Andres Zarta
-Author-email: andrezb5@gmail.com
+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
+Requires-Dist: nbformat>=5.1.3
+Requires-Dist: jupytext>=1.13.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
 
 # grader
 Automatic grading for DLAI courses. Designed to be compatible with Coursera's grading requirements.

dlai_grader-2.2.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+dlai_grader/__init__.py,sha256=JyMpb4I1llVdB6PPqzKFgEoAMX_v4JoRZ9hGYb_2ZaQ,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=0kMumpaOpKO0O5J00CbXZL-FZrsQ2-RobozDs5vDxnA,9573
+dlai_grader/notebook.py,sha256=MgxZFuetTXwwZ-HXSB5ItLVD_9LP45E0xHAngS0g4EU,12101
+dlai_grader/templates.py,sha256=gToTofemIAcgz5G343-RPLdfq0dJj66Nv4ERgHf7Ezw,9810
+dlai_grader/types.py,sha256=5uiFaF3aDn-vjxTp9ec-ND-PRqeeV2_NfPHS2ngGsRo,306
+dlai_grader/templates/Makefile,sha256=hQLhl-xLGw5WmACjlSGxlXA0Bc13XOY_4i5RaAunWlU,1904
+dlai_grader/templates/grader.py,sha256=AeazA3RzXTmplAwsFuDR9XKOluRj-EJSkhMLzJFGioo,899
+dlai_grader/templates/submission.ipynb,sha256=xfjI4j1ZJzU2cXwPnvjVKaP0mv5PKuDvrYFbyLI1SOs,749
+dlai_grader/templates/copy_assignment_sh/extrafile_n,sha256=5bodgRRh10TOa_pdHMnyQxGfFPb9yFDmSItG3lRpU2E,428
+dlai_grader/templates/copy_assignment_sh/extrafile_y,sha256=Y3xkYXSMeO3jJ2ioGFycdPlds46PxT9wQcK5SvQBX38,614
+dlai_grader/templates/dockerfile/data_n_solution_n,sha256=mD_fHhkzrGCCG3EPwXmafYVn1AoIcgBmSZLX8eCeH_g,447
+dlai_grader/templates/dockerfile/data_n_solution_y,sha256=9iSyDj3-Jwm6RyAHNtVUDeD-XrYODB61i-HB3HfA70g,480
+dlai_grader/templates/dockerfile/data_y_solution_n,sha256=i9nWcTAUCQzyhx3kM1aH64j0dkEMlYlEb6FFiE5k5oc,472
+dlai_grader/templates/dockerfile/data_y_solution_y,sha256=xs6p-puJ-j5AeIuHiESL7X9kNSFZVCZ3Wb9SAW9KlUU,505
+dlai_grader/templates/entry_py/solution_n_file_n.py,sha256=hZr5pcijXi-LOrJCInjEiiux5afIZXwhamdz_QjWCW0,2354
+dlai_grader/templates/entry_py/solution_n_file_y.py,sha256=maEfF2sjM9J1xPWppAtaR5Qf1sjCyPivvvjxdEzDCjU,3212
+dlai_grader/templates/entry_py/solution_y_file_n.py,sha256=ejRspmifrha0qY3WWUcHmbDQB86jXDpj6hdt-VFmntA,2402
+dlai_grader/templates/entry_py/solution_y_file_y.py,sha256=AXDb3qzLLf1Z-gYqC29xI6ucxj02bLk6GrOBVREeGqA,3280
+dlai_grader-2.2.0.dist-info/licenses/LICENSE,sha256=a_kch_UqdJPtyxk35QJr9O84K_koPixqWPYW9On4-io,1072
+dlai_grader-2.2.0.dist-info/METADATA,sha256=TX5JK8cU6TxEcJapcMe7rZ1BeJbbQ_YBQgye7k8a_dw,8776
+dlai_grader-2.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dlai_grader-2.2.0.dist-info/entry_points.txt,sha256=4OcSAUIluONXa3ymViQ7CBQ2Lk52nb6xZnfph1rlMnk,71
+dlai_grader-2.2.0.dist-info/top_level.txt,sha256=4YKtA3ztisFtx_g4hsGivy3J2NHnXxFziIMqawC8HWg,12
+dlai_grader-2.2.0.dist-info/RECORD,,

{dlai_grader-1.22.2.dist-info → dlai_grader-2.2.0.dist-info}/WHEEL

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

dlai_grader-1.22.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-dlai_grader/__init__.py,sha256=NJssrhk1f1ZuaTeZOoOhn2cgxdwJV9v6bXD-7WdoS7M,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=HybOy-0aPbJfxzQDjYOE2qo1myXKt0rlX90fzV1PXJo,8264
-dlai_grader/notebook.py,sha256=66-08JUF5l5AS3UETYyTOn0mDjSPJtEetP7guiz4cYQ,12125
-dlai_grader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dlai_grader/templates.py,sha256=u4BrPuDKefiyjKovxHPF0MbG73FvUIkLhgGpEWRYpL8,7843
-dlai_grader/types.py,sha256=_IIVbYL9cMmwA6in0aI5fEWCIaAMNcQbxG64X1P1CkE,335
-dlai_grader-1.22.2.dist-info/LICENSE,sha256=a_kch_UqdJPtyxk35QJr9O84K_koPixqWPYW9On4-io,1072
-dlai_grader-1.22.2.dist-info/METADATA,sha256=oQls7F3kEzBalJF1ao-tP5cvRaLOk_lD0VXA6lXyalc,8612
-dlai_grader-1.22.2.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-dlai_grader-1.22.2.dist-info/entry_points.txt,sha256=4OcSAUIluONXa3ymViQ7CBQ2Lk52nb6xZnfph1rlMnk,71
-dlai_grader-1.22.2.dist-info/top_level.txt,sha256=4YKtA3ztisFtx_g4hsGivy3J2NHnXxFziIMqawC8HWg,12
-dlai_grader-1.22.2.dist-info/RECORD,,