codingpirates-maze 0.1.0__py3-none-any.whl

importer/convert_level.py

@@ -0,0 +1,150 @@
+import xml.etree.ElementTree as ET
+import json
+import argparse
+import os
+import shutil
+
+import jinja2
+
+from .code_blocks import generate_toolbox_python, generate_python_from_blocks
+
+
+def create_levels_json(levelfiles: list, target_dir):
+    if isinstance(levelfiles, str):
+        levelfiles = [levelfiles]
+
+    loaded_json = []
+
+    for levelfile in levelfiles:
+        try:
+            print("creating level for", levelfile)
+            root = ET.parse(levelfile)
+            loaded_json.append(extract_level_json(levelfile, root, target_dir))
+        except (AttributeError, KeyError) as err:
+            print(f"Error handling file: {levelfile} : ", err)
+
+    return loaded_json
+
+
+def extract_level_json(levelfile, root, target_dir):
+    # Find the 'config' node and extract the JSON data
+    config_node = root.find('config')
+    json_data = config_node.text
+
+    # Load the JSON data as a Python dictionary
+    data = json.loads(json_data)
+
+    filename = os.path.basename(levelfile)
+    filename = os.path.splitext(filename)[0]
+    filename = f"{target_dir}/{filename}.json"
+
+    # Save the Python dictionary as a JSON file
+    with open(filename, 'w') as f:
+        json.dump(data, f, indent=2)
+    print(f" -- Saved json to '{filename}'")
+
+    return data
+
+
+# Get the directory of the current Python file
+_DIR_PATH = os.path.dirname(os.path.realpath(__file__))
+
+SKIN_PLAYER = {
+    # '[SKIN NAME]', ('[VARIABLE NAME IN PY]', '[CLASS NAME IN PY]')
+    'pvz': ('zombie', 'ZombiePlayer'),
+    'harvester': ('farmer', 'Harvester'),
+    'farmer': ('farmer', 'Farmer'),
+    'bee': ('bee', 'BeePlayer'),
+    'birds': ('bird', 'Bird'),
+    'collector': ('collector', 'Collector')
+}
+
+
+def create_maze_python(level_filename: str, maze_lesson_dirname: str, level_key, course, lesson, level, level_xml):
+    environment = jinja2.Environment(loader=jinja2.FileSystemLoader(_DIR_PATH))
+    skin = level['config']['properties'].get('skin')
+
+    contained_levels = level['config']['properties'].get("contained_level_names")
+
+    mapping = SKIN_PLAYER.get(skin)
+    if mapping:
+        (player, player_type) = mapping
+    else:
+        print(f" -- No player mapping found for {skin}")
+        return
+
+    template = environment.get_template(f"maze.py.j2")
+    toolbox = generate_toolbox_python(level_xml, player)
+    start_code = generate_python_from_blocks(level_xml.find("./blocks/start_blocks/xml"), player)
+    solution_code = generate_python_from_blocks(level_xml.find("./blocks/solution_blocks/xml"), player)
+
+    # Create the level / puzzle file
+    content = template.render(course=course, lesson=lesson, level=level, levelname=level_key, toolbox=toolbox,
+                              player=player, player_type=player_type, start_code=start_code)
+
+    with open(f"{level_filename}.py", mode="w", encoding="utf-8") as file:
+        file.write(content)
+
+    # Create the solution / test file, in the mirrored maze-repo lesson directory (no student repo puzzle file alongside it)
+    content = template.render(course=course, lesson=lesson, level=level, levelname=level_key, toolbox=toolbox,
+                              player=player, player_type=player_type, start_code=solution_code)
+
+    test_filename = os.path.join(maze_lesson_dirname, "test_" + os.path.basename(level_filename))
+
+    with open(f"{test_filename}.py", mode="w", encoding="utf-8") as file:
+        file.write(content)
+
+    # create a test_all.py file, if one does not exist
+    test_all_file = os.path.join(maze_lesson_dirname, "test_all.py")
+    print("test all file", test_all_file, "exist?", os.path.exists(test_all_file))
+    if not os.path.exists(test_all_file):
+        print("Copy test_all.py to ", test_all_file)
+        shutil.copy(os.path.join(_DIR_PATH, "test_all.py"), test_all_file)
+
+    print(f" -- wrote level to {level_filename}.py")
+
+
+def handle_level(levelfile, leveltype, levels_dirname, maze_lesson_dirname, level_filename, level_key, course, lesson, level):
+    """
+
+    :param levelfile: the source level file, typically a `.level`
+    :param leveltype: e.g. maze
+    :param levels_dirname: the shared flat directory (maze repo's src/maze/levels) to store the packaged level json in
+    :param maze_lesson_dirname: the mirrored lesson directory in the maze repo, to store the test_ solution file in
+    :param level_filename: the target filename without extension, including directory
+    :param level_key: the name of the level, which is also the key, e.g. "While Loops in Farmer"
+    :param course: the course json
+    :param lesson: the lesson json
+    :param level: the level json
+    :return:
+    """
+    print("HANDLE LEVEL: ", os.path.basename(levelfile), "type:", leveltype, "target:", level_filename)
+    os.makedirs(levels_dirname, exist_ok=True)
+    os.makedirs(maze_lesson_dirname, exist_ok=True)
+
+    # Load the level XML
+    root = ET.parse(levelfile)
+
+    # Extract the JSON, and store that
+    level_config = extract_level_json(levelfile, root, levels_dirname)
+    level['config'] = level_config
+
+    # Generate the level python, including the toolbox code
+    create_maze_python(level_filename, maze_lesson_dirname, level_key, course, lesson, level, root)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        prog='Level importer/converter',
+        description='Import a level file from code-dot-org and store it locally to the',
+        epilog='Text at the bottom of help')
+
+    parser.add_argument('levelfile', nargs='+',
+                        help='The file of the level to import and convert')
+
+    parser.add_argument('-t', '--target_dir', default="levels/", required=False,
+                        help='Target directory to store the converted files')
+
+    args = parser.parse_args()
+
+    create_levels_json(args.levelfile, args.target_dir)

importer/create_course.py

@@ -0,0 +1,278 @@
+import xml.etree.ElementTree as ET
+import json
+import argparse
+import os
+from os.path import join as joinpaths
+import re
+import jinja2
+from . import convert_level
+
+def sanitize_filename(filename, replace_spaces=False):
+    filename = re.sub(r'[\\/*?:\"<>|]', "-", filename)
+    if replace_spaces:
+        filename = filename.replace(" ", "_")
+    return filename
+
+
+# Defines the folders to look through
+# TODO Support "turtle" and "flappy"
+SUPPORTED_LEVEL_TYPES = [
+    ("maze", joinpaths("levels", "custom", "maze"), "level"),
+    ("unplug", joinpaths("levels", "custom", "unplug"), "level"),
+    ("standalone_video", joinpaths("levels", "custom", "standalone_video"), "level"),
+    ("external", "scripts", "external")
+]
+
+
+def find_level_file(levelname, startdir):
+    dir_prefix = joinpaths("dashboard", "config")
+    levelfile = f"{levelname}"
+
+    for leveltype in SUPPORTED_LEVEL_TYPES:
+        filename = joinpaths(startdir, dir_prefix, leveltype[1], levelfile + "." + leveltype[2])
+        if os.path.exists(filename):
+            return filename, leveltype[0]
+
+    return None, None
+
+
+def find_course_file(coursename, source_dir):
+    return joinpaths(source_dir, "dashboard", "config", "scripts_json", coursename + ".script_json")
+
+
+# Structure of the code-dot-org course script is:
+# - lesson_groups, e.g. High level "Loops" or "Conditionals"
+# - lessons, e.g. "Nested Loops in Maze"
+# - lesson_activities, e.g. "Warm up", "Main Activity", "Wrap Up"
+# - activity_sections, e.g. "Skill Building", "Prediction"
+# - script_levels, e.g. each level in skill building
+
+
+#
+#
+# An lesson_activity looks like this, and is not needed to generate the puzzle files
+#
+#   "key": "8fe0f456-c4bd-4d50-bee3-fa311f5cc147",
+#   "position": 1,
+#   "properties": {
+#     "duration": 10,
+#     "name": "Warm Up"
+#   },
+#   "seeding_key": {
+#     "lesson_activity.key": "8fe0f456-c4bd-4d50-bee3-fa311f5cc147",
+#     "lesson.key": "Nested Loops in Maze",
+#     "lesson_group.key": "csf_loops",
+#     "script.name": "coursed-2023"
+#   }
+#
+#
+# An activity_section looks like this:
+#  {
+#    "key": "b9ae7539-4e07-42a1-a318-77b57bcebe7f",
+#    "position": 1,
+#    "properties": {
+#      "description": "These puzzles might sprout some questions, so have the students work in pairs or implement the
+#                     \"Ask three before you ask me\" rule (have the students ask three other peers for help before they
+#                     go to the teacher.) This will spark discussions that will develop each student's understanding.",
+#      "name": "If/Else with Bee"
+#    },
+#    "seeding_key": {
+#      "activity_section.key": "b9ae7539-4e07-42a1-a318-77b57bcebe7f",
+#      "lesson_activity.key": "293c782d-3e53-4092-bea7-c4ed864214b0"
+#    }
+#  },
+
+
+# course file e.g. 
+# code-dot-org/dashboard/config/scripts_json/coursed-2023.script_json
+# code-dot-org/dashboard/config/levels/custom/maze/courseD_bee_conditionals3_2023.level
+
+
+# WIP
+# class Course:
+#
+#     @staticmethod
+#     def from_json(json):
+#
+#
+#     def __init__(self, name: str, family_name: str):
+#         self.name = name
+#         self.family_name = family_name
+#         self.dir_name = sanitize_filename(name.lower())
+
+def generate_courses(coursename, source_dir, target_dir, maze_dir):
+    coursefile = find_course_file(coursename, source_dir)
+    print("Found course file", coursefile)
+    with open(coursefile) as f:
+        course = json.load(f)
+        course['key'] = coursename
+
+        lesson_group_seq = 0
+
+        # A lesson_group looks like this:
+        #
+        #   "key": "csf_conditionals",
+        #   "user_facing": true,
+        #   "position": 5,
+        #   "properties": {
+        #     "display_name": "Conditionals"
+        #   },
+        #   "seeding_key": {
+        #     "lesson_group.key": "csf_conditionals",
+        #     "script.name": "coursed-2023"
+        #   }
+        for lesson_group in course.get("lesson_groups"):
+            lesson_group_seq += 1
+
+            # Get relevant properties from lesson_group
+            group_name = lesson_group["properties"]["display_name"]
+            lesson_group_key = lesson_group["key"]
+
+            # Directory name for Group
+
+            # A lesson looks like this:
+            #
+            #   "key": "If/Else with Bee",
+            #   "name": "If/Else with Bee",
+            #   "absolute_position": 14,
+            #   "lockable": false,
+            #   "has_lesson_plan": true,
+            #   "relative_position": 14,
+            #   "properties": {
+            #     "creative_commons_license": "Creative Commons BY-NC-SA",
+            #     "overview": "In this **skill-building** lesson, your class will continue to code with conditionals,
+            #                 allowing them to write code that functions differently depending on the specific
+            #                 conditions the program encounters.",
+            #     "preparation": " - Play through the puzzles to find any potential problem areas for your class.\n",
+            #     "purpose": "After being introduced to conditionals in \"Conditionals with Cards,\" students will now
+            #                practice using them in their programs. The \"if / else\" blocks will allow for a more
+            #                flexible program. The bee will only collect nectar *if* there is a flower or make honey
+            #                *if* there is a honeycomb. ",
+            #     "student_overview": "Now that you understand conditionals, it's time to program Bee to use them when
+            #                         collecting honey and nectar. ",
+            #     ["unplugged": true] # Only present when unplugged
+            #   },
+            #   "seeding_key": {
+            #     "lesson.key": "If/Else with Bee",
+            #     "lesson_group.key": "csf_conditionals",
+            #     "script.name": "coursed-2023"
+            #   }
+            for lesson in course.get("lessons"):
+                if lesson["seeding_key"]["lesson_group.key"] == lesson_group_key:
+
+                    props = lesson["properties"]
+
+                    cc_license = props.get("creative_commons_license")
+                    lesson_seq = lesson["absolute_position"]
+                    lesson_key = lesson["key"]
+                    lesson_unplugged = bool(props.get("unplugged"))
+
+                    lesson_name = lesson["name"]
+
+                    # Directory name for the lesson (student repo, puzzle files)
+                    course_dirname = f"{args.target_dir}/{lesson_group['seeding_key']['script.name']}".lower()
+                    lesson_dirname = sanitize_filename(f"{lesson_seq} - {group_name} - {lesson_key}")
+                    lesson_dirname = f"{course_dirname}/{lesson_dirname}"
+
+                    # Mirrored directory name for the lesson (maze repo, test_ solution files only)
+                    maze_course_dirname = f"{args.maze_dir}/{lesson_group['seeding_key']['script.name']}".lower()
+                    maze_lesson_dirname = f"{maze_course_dirname}/{sanitize_filename(f'{lesson_seq} - {group_name} - {lesson_key}')}"
+
+                    # Shared flat folder for all packaged level json files, in the maze repo
+                    maze_levels_dirname = f"{args.maze_dir}/src/maze/levels"
+
+                    # Only continue if the lesson is under Creative Commons license
+                    if cc_license:
+                        os.makedirs(lesson_dirname, exist_ok=True)
+
+                        # TODO Make Lesson MD file for the lesson
+
+                        # A script_level looks like this:
+                        #
+                        #  "chapter": 120,
+                        #  "position": 4,
+                        #  "activity_section_position": 2,
+                        #  "assessment": false,
+                        #  "properties": {
+                        #    "level_keys": [
+                        #      "courseD_bee_conditionals3_2023"
+                        #    ],
+                        #    "progression": "Skill Building"
+                        #  },
+                        #  "bonus": false,
+                        #  "seeding_key": {
+                        #    "script_level.level_keys": [
+                        #      "courseD_bee_conditionals3_2023"
+                        #    ],
+                        #    "lesson.key": "If/Else with Bee",
+                        #    "lesson_group.key": "csf_conditionals",
+                        #    "script.name": "coursed-2023",
+                        #    "activity_section.key": "c3e5d3a5-f776-4bd6-93d6-821025f2c40f"
+                        #  },
+                        #  "level_keys": [
+                        #    "courseD_bee_conditionals3_2023"
+                        #  ]
+                        for level in course.get("script_levels"):
+                            props = level["properties"]
+                            level_key:str = level["level_keys"][0]  # TODO, check if there could ever be more
+                            level_seq = level["position"]
+                            level_progression = props.get("progression")
+                            section_pos = level["activity_section_position"]
+
+                            if lesson_key == level["seeding_key"]["lesson.key"]:
+                                levelfile, leveltype = find_level_file(level_key, source_dir)
+
+                                if not levelfile:
+                                    print(f"No levefile foud for: {level_key}")
+                                    continue
+
+                                if level_progression:
+                                    level_progression = sanitize_filename(level_progression)
+                                    level_filename = f"{lesson_dirname}/{level_seq}_{level_progression}_{section_pos}"
+                                else:
+                                    predict = "_predict" if "predict" in levelfile else ""
+                                    level_filename = f"{lesson_dirname}/{level_seq}_{leveltype}{predict}"
+
+                                if leveltype == 'maze':
+                                    convert_level.handle_level(levelfile, leveltype, maze_levels_dirname, maze_lesson_dirname, level_filename, level_key, course, lesson, level)
+
+                                elif leveltype == 'unplug':
+                                    print("unplug levels not yet implemented")
+                                elif leveltype == 'standalone_video':
+                                    print("standalone_video levels not yet implemented")
+                                elif leveltype == 'external':
+                                    print("external levels not yet implemented")
+
+                    else:
+                        print(f"Skipping lesson '{lesson_name}' as it does not have a creative_commons_license")
+
+                    if os.path.isdir(lesson_dirname) and not bool(os.listdir(lesson_dirname)):
+                        # If the directory exist and is empty after looping through all the levels, remove it
+                        os.rmdir(lesson_dirname)
+
+                    if os.path.isdir(maze_lesson_dirname) and not bool(os.listdir(maze_lesson_dirname)):
+                        os.rmdir(maze_lesson_dirname)
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        prog='Course importer/converter',
+        description='Import a course file from code-dot-org and create empty puzzle files',
+        epilog='example: \ncreate_course -s ../code-dot-org -t ../code-org-python -m . coursed-2023')
+
+    parser.add_argument('-s', '--source_dir',
+                        help='The root folder for code-dot-org codebase, to look for courses within')
+
+    parser.add_argument('-t', '--target_dir', default="course/", required=False,
+                        help='Target directory of the student-facing repo to store the puzzle files in')
+
+    parser.add_argument('-m', '--maze_dir', required=True,
+                        help='Root directory of the maze repo, to store level json and test_ solution files in')
+
+    parser.add_argument('coursename',
+                        help='The name of the course to import and convert')
+
+    args = parser.parse_args()
+
+    generate_courses(args.coursename, args.source_dir, args.target_dir, args.maze_dir)

importer/lesson.md.j2

@@ -0,0 +1,3 @@
+# {lesson.lesson_name}
+
+{lesson.student_overview}

importer/maze.py.j2

@@ -0,0 +1,20 @@
+from maze import Puzzle, {{player_type}}
+
+maze = Puzzle.from_file("{{levelname}}")
+{{player}}: {{player_type}} = maze.player
+
+'''
+https://studio.code.org/s/{{course.key}}/lessons/{{lesson.absolute_position}}/levels/{{level.position}}
+
+{{level.config.properties.long_instructions}}
+
+---
+{{toolbox}}
+'''
+
+# When run
+
+{{start_code}}
+
+# Keep this
+Puzzle.done()

importer/test.py

@@ -0,0 +1,24 @@
+#from code_blocks import generate_python_from_blocks, generate_toolbox_python
+import xml.etree.ElementTree as ET
+import os
+#
+#
+# # root = ET.parse("/Users/sgrinsted/ws/codingpirates/code-dot-org/dashboard/config/levels/custom/maze/courseD_farmer_while_challenge1_2023.level")
+# root = ET.parse("/Users/sgrinsted/ws/codingpirates/code-dot-org/dashboard/config/levels/custom/maze/courseD_maze_until10_2023.level")
+#
+# solution = root.find("./blocks/solution_blocks/xml")
+#
+# code = generate_python_from_blocks(solution, player="zombie")
+#
+# print(code)
+
+
+def chorus():
+    print("doo doo, doo doo doo doo")
+
+
+for person in ("Baby", "Mommy"):
+    for i in range(4):
+        print(person + " Shark")
+        chorus()
+

importer/test_all.py

@@ -0,0 +1,24 @@
+import subprocess
+import os
+
+def run_script(script_path):
+    env = os.environ.copy()
+    # Add your custom environment variable
+    env["TESTMODE"] = "True"
+
+    result = subprocess.run(['python', script_path], env=env, stdout=subprocess.PIPE)
+    output = result.stdout.decode('utf-8').strip()
+    
+    print(f"{output} {script_path}")
+
+def visit_dir(dir):
+    for file in os.listdir(dir):
+        if os.path.isdir(file):
+            visit_dir(os.path.join(dir, file))
+        elif file.endswith(".py") and file != "test_all.py":
+            run_script(os.path.join(dir, file))
+
+
+if __name__ == "__main__":
+    visit_dir(".")
+    print("DONE")

maze/__init__.py

@@ -0,0 +1,9 @@
+from .maze import Maze, Player, Cell, SquareType 
+from .bee import BeeMazeType, BeeFeatureType, BeeCell, BeePlayer, CloudType, FlowerColor
+from .pvz import ZombieMazeType, ZombieCell, ZombiePlayer
+from .farmer import FarmerMazeType, FarmerCell, Farmer
+from .harvester import HarvesterMazeType, HarvesterCell, Harvester
+from .birds import BirdsMazeType, BirdsCell, Bird
+from .collector import CollectorMazeType, CollectorCell, CollectorPath, Collector
+from .puzzle import Puzzle
+from .screencapture import capture