prepare-assignment 0.1.0__tar.gz

prepare_assignment-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 prepare-assignment
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

prepare_assignment-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: prepare-assignment
+Version: 0.1.0
+Summary: Prepare assignment
+License: MIT
+Author: Bonajo
+Author-email: m.bonajo@fontys.nl
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: gitpython (>=3.1.31,<4.0.0)
+Requires-Dist: importlib-resources (>=5.12.0,<6.0.0)
+Requires-Dist: jsonschema (>=4.17.3,<5.0.0)
+Requires-Dist: prepare-toolbox (>=0.2.0,<0.3.0)
+Requires-Dist: ruamel-yaml (>=0.17.21,<0.18.0)
+Requires-Dist: virtualenv (>=20.24.5,<21.0.0)
+Description-Content-Type: text/markdown
+
+# Prepare assignment
+
+Prepare assignment is a helper tool to prepare assignments at Fontys Venlo.
+
+## Dependencies
+
+- Git
+- Python >=3.8
+- Docker (if using Docker based actions)
+
+## Limitations
+
+For now cloning the action repositories is done using SSH, 
+so if you don't have that setup it will not work

prepare_assignment-0.1.0/README.md

@@ -0,0 +1,14 @@
+# Prepare assignment
+
+Prepare assignment is a helper tool to prepare assignments at Fontys Venlo.
+
+## Dependencies
+
+- Git
+- Python >=3.8
+- Docker (if using Docker based actions)
+
+## Limitations
+
+For now cloning the action repositories is done using SSH, 
+so if you don't have that setup it will not work

prepare_assignment-0.1.0/prepare_assignment/__main__.py

@@ -0,0 +1,4 @@
+from prepare_assignment.core.cli import main
+
+if __name__ == '__main__':
+    main()

prepare_assignment-0.1.0/prepare_assignment/core/cli.py

@@ -0,0 +1,81 @@
+import argparse
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+from prepare_toolbox.file import get_matching_files
+from ruamel.yaml import YAML
+
+from prepare_assignment.core.preparer import prepare_actions
+from prepare_assignment.core.runner import run
+from prepare_assignment.core.validator import validate_prepare
+from prepare_assignment.data.errors import ValidationError, DependencyError
+from prepare_assignment.utils import set_logger_level
+
+
+def add_commandline_arguments(parser: argparse.ArgumentParser) -> None:
+    """
+    Add command line arguments to the argparser
+    :param parser: The parser to add the arguments to
+    """
+    parser.add_argument("-f", "--file", action="store", help="Configuration file")
+    parser.add_argument("-v", "--verbosity", action="count", help="increase output verbosity", default=0)
+
+
+def __get_prepare_file(file: Optional[str]) -> str:
+    """
+    Try and find the correct prepare_assignment.y(a)ml
+    :param file: file name provided by the user
+    :return: path to file
+    :raises FileNotFoundError: if file doesn't exist
+    :raises AssertionError: if there is both a prepare_assignment.yml and a prepare_assignment.yml and no file is provided by the user
+    :raises FileNotFoundError: if the provided 'file' is not a file
+    """
+    if file is None:
+        files = get_matching_files("prepare_assignment.y{,a}ml")
+        if len(files) == 0:
+            raise FileNotFoundError("No prepare_assignment.yml file found in working directory")
+        elif len(files) > 1:
+            raise AssertionError("There is both a prepare_assignment.yml and a prepare_assignment.yml,"
+                                 " use the -f flag to specify which file to use")
+        file = files[0]
+    else:
+        file = str(Path(os.path.join(os.getcwd(), file)))
+        if not os.path.isfile(file):
+            raise FileNotFoundError(f"Supplied file: '{file}' is not a file")
+    return file
+
+
+def main() -> None:
+    """
+    Parse 'prepare_assignment.y(a)ml' and execute all steps
+    """
+    # Handle command line arguments
+    parser = argparse.ArgumentParser()
+    add_commandline_arguments(parser)
+    args = parser.parse_args()
+
+    # Set the logger
+    logger = logging.getLogger("prepare_assignment")
+    set_logger_level(logger, args.verbosity)
+
+    # Get the prepare_assignment.yml file
+    file = __get_prepare_file(args.file)
+    logger.info(f"Found prepare_assignment config file at: {file}")
+
+    # Load the file
+    yaml = YAML(typ='safe')
+    path = Path(file)
+    prepare = yaml.load(path)
+
+    # Execute all steps
+    os.chdir(os.path.dirname(path))
+    try:
+        validate_prepare(file, prepare)
+        mapping = prepare_actions(file, prepare['steps'])
+        run(prepare, mapping)
+    except ValidationError as ve:
+        logger.error(ve.message)
+    except DependencyError as de:
+        logger.error(de.message)

prepare_assignment-0.1.0/prepare_assignment/core/preparer.py

@@ -0,0 +1,232 @@
+import json
+import logging
+import os
+import shutil
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, List, Optional, TypedDict
+
+from git import Repo
+from importlib_resources import files
+from virtualenv import cli_run # type: ignore
+
+from prepare_assignment.core.validator import validate_action_definition, validate_action, load_yaml, \
+    validate_default_values
+from prepare_assignment.data.action_definition import ActionDefinition, CompositeActionDefinition, \
+    PythonActionDefinition
+from prepare_assignment.data.action_properties import ActionProperties
+from prepare_assignment.data.errors import DependencyError, ValidationError
+from prepare_assignment.utils.cache import get_cache_path
+
+# Set the cache path
+cache_path = get_cache_path()
+# Get the logger
+logger = logging.getLogger("prepare_assignment")
+# Load the actions template file
+template_file = files().joinpath('../schemas/actions.schema.json_template')
+template: str = template_file.read_text()
+
+
+def __repo_path(props: ActionProperties) -> Path:
+    return Path(os.path.join(cache_path, props.organization, props.name, props.version, "repo"))
+
+
+def __download_action(props: ActionProperties) -> Path:
+    """
+    Download (using git clone) the action
+    :param organization: GitHub organization/username
+    :param action: action name
+    :returns str: the path where the repo is checked out
+    """
+    path: Path = __repo_path(props)
+    path.mkdir(parents=True, exist_ok=True)
+    # For now use ssh protocol, need to figure out how to use system defined one
+    git_url: str = f"git@github.com:{props.organization}/{props.name}.git"
+    logger.debug(f"Cloning repository: {git_url}")
+    repo = Repo.clone_from(git_url, path)
+    if props.version != "latest":
+        logger.debug(f"Checking out correct version of repository: {props.version}")
+        repo.git.checkout(props.version)
+    return path
+
+
+def __build_json_schema(organization: str, action: ActionDefinition) -> str:
+    logger.debug(f"Building json schema for '{action.id}'")
+    schema = template.replace("{{action-id}}", action.id)
+    schema = schema.replace("{{organization}}", organization)
+    schema = schema.replace("{{action-name}}", action.name)
+    schema = schema.replace("{{action-description}}", action.description)
+    required: List[str] = []
+    properties: List[str] = []
+    for inp in action.inputs:
+        properties.append(inp.to_schema_definition())
+        if inp.required:
+            required.append(inp.name)
+    if len(properties) > 0:
+        output = ',    \n"with": {\n      "type": "object",\n      "additionalProperties": false,\n      "properties": {\n'
+        output += ",\n".join(properties) + "\n    }"
+        if len(required) > 0:
+            schema = schema.replace("{{required}}", ', "with"')
+            output += ',\n    "required": [' + ", ".join(map(lambda x: f'"{x}"', required)) + ']\n    }'
+        else:
+            schema = schema.replace("{{required}}", "")
+            output += "\n}"
+        schema = schema.replace("{{with}}", output)
+    return schema
+
+
+def __action_properties(action: str) -> ActionProperties:
+    parts = action.split("/")
+    if len(parts) > 2:
+        raise AssertionError("Actions cannot have more than one slash")
+    elif len(parts) == 1:
+        parts.insert(0, "prepare_assignment-assignment")
+    organization: str = parts[0]
+    name = parts[1]
+    split = name.split("@")
+    version: str = "latest"
+    action_name: str = name
+    if len(split) > 2:
+        raise AssertionError("Cannot have multiple '@' symbols in the name")
+    elif len(split) == 2:
+        action_name = split[0]
+        version = split[1]
+    return ActionProperties(organization, action_name, version)
+
+
+def __action_dict_to_definition(action: Any, path: str) -> ActionDefinition:
+    if action["runs"]["using"] == "composite":
+        return CompositeActionDefinition.of(action, path)
+    else:
+        return PythonActionDefinition.of(action, path)
+
+
+def __action_install_dependencies(action_path: str) -> None:
+    venv_path = os.path.join(action_path, "venv", "bin", "python")
+    repo_path = os.path.join(action_path, "repo")
+    requirements_path = os.path.join(repo_path, "requirements.txt")
+    pyproject_path = os.path.join(repo_path, "pyproject.toml")
+    has_requirements = os.path.isfile(requirements_path)
+    has_pyproject = os.path.isfile(pyproject_path)
+
+    if not has_requirements and not has_pyproject:
+        return
+
+    result: Optional[subprocess.CompletedProcess[Any]] = None
+    if has_requirements:
+        logger.debug(f"Installing dependencies from '{requirements_path}'")
+        args = [venv_path] + f"-m pip install -r {requirements_path}".split(" ")
+        result = subprocess.run(args, capture_output=True)
+    elif has_pyproject:
+        logger.debug(f"Installing dependencies from '{pyproject_path}'")
+        args = [venv_path] + f"-m pip install .".split()
+        result = subprocess.run(args, capture_output=True, cwd=repo_path)
+
+    if result is not None and result.returncode == 1:
+        log_path = os.path.join(cache_path, "logs")
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        file = os.path.join(log_path, f'{timestamp}-dependencies.log')
+        Path(log_path).mkdir(parents=True, exist_ok=True)
+        with open(file, 'wb') as handle:
+            handle.write(result.stderr)
+        raise DependencyError(f"Unable to install dependencies for '{repo_path}', see '{file}' for more info")
+
+
+class ActionStuff(TypedDict):
+    schema: Any
+    action: ActionDefinition
+
+
+def __prepare_actions(file: str, actions: List[Any], parsed: Optional[Dict[str, ActionStuff]] = None) \
+        -> Dict[str, ActionStuff]:
+    # Unfortunately we cannot do this as a default value, see:
+    # https://docs.python-guide.org/writing/gotchas/#mutable-default-arguments
+    if parsed is None:
+        parsed = {}
+    if len(actions) == 0:
+        logger.debug("All actions prepared")
+        return parsed
+
+    action_def = actions.pop()
+    act: str = action_def["uses"]
+    json_schema: Optional[Any] = None
+    # Check if we have already loaded the action
+    if parsed.get(act, None) is None:
+        logger.debug(f"Action '{act}' has not been loaded in this run")
+        props = __action_properties(act)
+
+        # Check if action (therefore the path) has already been downloaded in previous run
+        action_path = os.path.join(cache_path, props.organization, props.name, props.version)
+        action: Optional[ActionDefinition] = None
+        repo_path = __repo_path(props)
+        yaml_path = os.path.join(repo_path, "action.yml")
+        if os.path.isdir(action_path):
+            logger.debug(f"Action '{act}' is already available, loading from disk")
+            with open(os.path.join(action_path, f"{props.name}.schema.json"), "r") as handle:
+                json_schema = json.load(handle)
+            action_yaml = load_yaml(yaml_path)
+            action = __action_dict_to_definition(action_yaml, action_path)
+        else:
+            logger.debug(f"Action '{act}' is not available on this system")
+            # Download the action (clone the repository)
+            __download_action(props)
+            # Validate that the action.yml is valid
+            action_yaml = validate_action_definition(yaml_path)
+            action = __action_dict_to_definition(action_yaml, action_path)
+            validate_default_values(action)
+            # Check if it is a composite action, in that case we might need to retrieve more actions
+            if isinstance(action, CompositeActionDefinition):
+                logger.debug(f"Action '{act}' is a composite action, preparing sub-actions")
+                all_actions: List[Any] = []
+                for step in action.steps:
+                    name = step.get("uses", None)
+                    if name is not None:
+                        all_actions.append(step)
+                parsed = __prepare_actions(str(repo_path), all_actions, parsed)
+            else:
+                main_path = os.path.join(repo_path, action.main)  # type: ignore
+                if not os.path.isfile(main_path):
+                    raise ValidationError(f"Main file '{action.main}' does not exist for action '{action.name}'") # type: ignore
+            # Now we can build a schema for this action
+            schema = __build_json_schema(props.organization, action)
+            json_schema = json.loads(schema)
+            with open(os.path.join(action_path, f"{props.name}.schema.json"), 'w') as handle:
+                handle.write(schema)
+            # Create a virtualenv for this action
+            cli_run([os.path.join(action_path, "venv")])
+            # Install dependencies
+            __action_install_dependencies(action_path)
+        parsed[act] = {"schema": json_schema, "action": action}
+    else:
+        json_schema = parsed[act]["schema"]
+    if action_def.get("with", None) is None:
+        action_def["with"] = {}
+    validate_action(file, action_def, json_schema)
+    return __prepare_actions(file, actions, parsed)
+
+
+def prepare_actions(prepare_file: str, steps: Dict[str, Any]) -> Dict[str, ActionDefinition]:
+    """
+    Make sure that the action is available.
+    If not available:
+    1. Clone the repository
+    2. Checkout the correct version
+    3. Generate json schema for validation
+    :param steps: The actions to prepare_assignment
+    :param prepare_file
+    :return: None
+    """
+    logger.debug("========== Preparing actions")
+    all_actions: List[Any] = []
+    # DON'T FORGET TO REMOVE, ONLY FOR DEVELOPMENT
+    # shutil.rmtree(cache_path, ignore_errors=True)
+    # Iterate through all the actions to make sure that they are available
+    for step, actions in steps.items():
+        for action in actions:
+            # If the action is a run command, we don't need to do anything
+            if action.get("uses", None) is not None:
+                all_actions.append(action)
+    mapping = __prepare_actions(prepare_file, all_actions)
+    logger.debug("✓ All actions downloaded and valid")
+    return {k: v["action"] for k, v in mapping.items()}

prepare_assignment-0.1.0/prepare_assignment/core/runner.py

@@ -0,0 +1,72 @@
+import json
+import logging
+import os.path
+import shlex
+import subprocess
+import sys
+from typing import Any, Dict
+
+from importlib_resources import files
+
+from prepare_assignment.data.action_definition import ActionDefinition, PythonActionDefinition
+
+# Get the logger
+logger = logging.getLogger("prepare_assignment")
+
+
+def __execute_action(action: PythonActionDefinition, inputs: Dict[str, str]) -> None:
+    venv_path = os.path.join(action.path, "venv")
+    main_path = os.path.join(action.path, "repo", action.main)
+    executable = os.path.join(venv_path, "bin", "python")
+    env = os.environ.copy()
+    env["VIRTUAL_ENV"] = venv_path
+    for key, value in inputs.items():
+        sanitized = "PREPARE_" + key.replace(" ", "_").upper()
+        env[sanitized] = value
+    result = subprocess.run([executable, main_path], capture_output=True, env=env)
+    if result.returncode == 1:
+        logger.error(f"Failed to execute '{action.name}', action failed with status code {result.returncode}")
+        if result.stderr:
+            logger.error(result.stderr.decode("utf-8"))
+        if not result.stderr and result.stdout:
+            logger.error(result.stdout.decode("utf-8"))
+
+
+def __execute_shell_command(command: str) -> None:
+    args = shlex.split(f"bash -c {shlex.quote(command)}")
+    result = subprocess.run(args, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode == 1:
+        print(result.stderr)
+    else:
+        print(result)
+
+
+def __handle_action(mapping: Dict[str, ActionDefinition], action: Any, inputs: Dict[str, Any]) -> None:
+    # TODO: Command substitution
+    for key, value in inputs.items():
+        inputs[key] = json.dumps(value)
+    # Check what kind of actions it is
+    action_type = action.get("uses", None)
+    if action_type is None:
+        command = action.get("run")
+        __execute_shell_command(command)
+    else:
+        uses = action.get("uses", None)
+        action_definition = mapping.get(uses)
+
+        if isinstance(action_definition, PythonActionDefinition):
+            __execute_action(action_definition, inputs)
+        else:
+            for act in action_definition.steps:  # type: ignore
+                __handle_action(mapping, act, inputs)
+
+
+def run(prepare: Dict[str, Any], mapping: Dict[str, ActionDefinition]) -> None:
+    logger.debug("========== Running prepare_assignment assignment")
+    for step, actions in prepare["steps"].items():
+        logger.debug(f"Running step: {step}")
+        for action in actions:
+            inputs = action.get("with", {})
+            __handle_action(mapping, action, inputs)
+
+    logger.debug("✓ Prepared :)")

prepare_assignment-0.1.0/prepare_assignment/core/validator.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Dict, Any, Type
+
+from importlib_resources import files
+from jsonschema.exceptions import ValidationError
+from jsonschema.validators import validate
+from ruamel.yaml import YAML
+
+from prepare_assignment.data.action_definition import ActionDefinition
+from prepare_assignment.data.errors import ValidationError as VE
+from prepare_assignment.utils.default_validator import DefaultValidatingValidator
+
+logger = logging.getLogger("prepare_assignment")
+yaml = YAML(typ='safe')
+
+type_map: Dict[str, Type] = {
+    "string": type(''),
+    "integer": type(1),
+    "number": type(1.23),
+    "array": type([]),
+    "boolean": type(True)
+}
+
+
+def validate_prepare(prepare_file: str, prepare: Dict[str, Any]) -> None:
+    """
+    Validate that the prepare_assignment.y(a)ml file has the correct syntax
+    NOTE: this does not validate all actions, this is done in the
+    validate_actions function
+    :param prepare: The parsed yaml
+    :param prepare_file
+    :return: None
+    :raises: ValidationError: if schema is not valid
+    """
+    logger.debug("========== Validating config file")
+    # Load the validation jsonschema
+    schema_path = files().joinpath('../schemas/prepare.schema.json')
+    schema: Dict[str, Any] = json.loads(schema_path.read_text())
+
+    # Validate prepare_assignment.y(a)ml
+    try:
+        validate(prepare, schema, cls=DefaultValidatingValidator)
+    except ValidationError as ve:
+        message = f"Error in: {prepare_file}, unable to verify '{ve.json_path}'\n\t -> {ve.message}"
+        raise VE(message)
+    logger.debug("✓ Prepare file is valid")
+
+
+def validate_action(file: str, action: Dict[str, Any], json_schema: Any) -> None:
+    """
+    Validate all actions based on their respective json schemas
+    NOTE: this assumes that all actions are available and that it's json schema has been generated
+    :param action The action definition
+    :param json_schema
+    :param file
+    :return: None
+    :raises: ValidationError if an action cannot be validated against its respective schema
+    """
+    name = action["uses"]
+    logger.debug(f"Validating '{name}'")
+    try:
+        # validate(action, json_schema, cls=DefaultValidatingValidator)
+        DefaultValidatingValidator(json_schema).validate(action)
+    except ValidationError as ve:
+        message = f"Error in: {file}, unable to verify action '{name}'\n\t -> {ve.json_path}: {ve.message}"
+        raise VE(message)
+
+
+def load_yaml(path: str | os.PathLike[str] | os.PathLike) -> Any:
+    path = Path(path)
+    return yaml.load(path)
+
+
+def validate_action_definition(path: str | os.PathLike[str] | os.PathLike) -> Any:
+    logger.debug("Validating action definition")
+
+    # Load the validation jsonschema
+    schema_path = files().joinpath('../schemas/action.schema.json')
+    schema: Dict[str, Any] = json.loads(schema_path.read_text())
+
+    action_definition = load_yaml(path)
+
+    try:
+        validate(action_definition, schema, cls=DefaultValidatingValidator)
+        # Overwrite the action.yml file as we might have added default values
+        with open(path, 'w') as handle:
+            yaml.dump(action_definition, handle)
+    except ValidationError as ve:
+        message = f"Unable to verify: {path}\n\t -> {ve.json_path}: {ve.message}"
+        raise VE(message)
+
+    return action_definition
+
+
+def validate_default_values(action: ActionDefinition) -> None:
+    for input in action.inputs:
+        if input.default is None:
+            continue
+
+        # Check that the default type is of the type we expect
+        if not isinstance(input.default, type_map[input.type]):
+            raise VE(
+                f"Unable to verify action '{action.name}', default value for input '{input.name}' is of the wrong type"
+                f", expected '{input.type}', but got '{type(input.default)}'")
+
+        # If we expect an array, validate that all elements are of the correct type
+        if input.type == "array":
+            # we need to ignore the type here as both PyCharm and mypy don't know we validated the file already and
+            # we know that there myst be option.items when the type is array
+            item_type = type_map[input.items]  # type: ignore
+            # noinspection PyTypeChecker
+            for item in input.default:
+                if item_type != type(item):
+                    raise VE(f"Default item: {item}, should be of type: {item_type}, "
+                             f"but is of type: {type(item)}")

prepare_assignment-0.1.0/prepare_assignment/data/action_definition.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import json
+from abc import ABC
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional, List, TypedDict
+
+
+@dataclass
+class PythonActionDefinitionInput:
+    name: str
+    description: str
+    required: bool
+    type: str
+    default: Optional[str] | Optional[List[Any]] = None
+    items: Optional[str] = None
+
+    @classmethod
+    def of(cls, name: str, yaml: Dict[str, Any]) -> PythonActionDefinitionInput:
+        default = yaml.get("default", None)
+        items = yaml.get("items", None)
+        return cls(
+            name=name,
+            description=yaml["description"],
+            required=yaml["required"],
+            type=yaml["type"],
+            default=default,
+            items=items
+        )
+
+    def to_schema_definition(self) -> str:
+
+        properties = [f'"type": "{self.type}"']
+        if self.type == "array":
+            properties.append(f'"items": {{ "type": "{self.items}" }}')
+        if self.default is not None:
+            properties.append(f'"default": {json.dumps(self.default)}')
+        joined = ",\n  ".join(properties)
+        return f'"{self.name}": {{\n  {joined}\n}}'
+
+
+@dataclass
+class ActionDefinition(ABC):
+    id: str
+    name: str
+    description: str
+    inputs: List[PythonActionDefinitionInput]
+    path: str
+
+    @staticmethod
+    def _dict_to_inputs(dictionary: Dict[str, Any]) -> List[PythonActionDefinitionInput]:
+        return [PythonActionDefinitionInput.of(key, value) for key, value in dictionary.items()]
+
+
+@dataclass
+class PythonActionDefinition(ActionDefinition):
+    main: str
+
+    @classmethod
+    def of(cls, yaml: Dict[str, Any], path: str) -> PythonActionDefinition:
+        inputs = yaml.get("inputs", {})
+        return cls(
+            id=yaml["id"],
+            name=yaml["name"],
+            description=yaml["description"],
+            inputs=ActionDefinition._dict_to_inputs(inputs),
+            main=yaml["runs"]["main"],
+            path=path
+        )
+
+
+@dataclass
+class CompositeActionDefinition(ActionDefinition):
+    steps: List[Any]
+
+    @classmethod
+    def of(cls, yaml: Dict[str, Any], path: str) -> CompositeActionDefinition:
+        inputs = yaml.get("inputs", {})
+        return cls(
+            id=yaml["id"],
+            name=yaml["name"],
+            description=yaml["description"],
+            steps=yaml["runs"]["steps"],
+            inputs=ActionDefinition._dict_to_inputs(inputs),
+            path=path
+        )

prepare_assignment-0.1.0/prepare_assignment/data/action_properties.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ActionProperties:
+    organization: str
+    name: str
+    version: str

prepare_assignment-0.1.0/prepare_assignment/data/errors.py

@@ -0,0 +1,12 @@
+class ValidationError(Exception):
+
+    def __init__(self, message: str):
+        super().__init__(message)
+        self.message = message
+
+
+class DependencyError(Exception):
+
+    def __init__(self, message: str):
+        super().__init__(message)
+        self.message = message

prepare_assignment-0.1.0/prepare_assignment/schemas/action.schema.json

@@ -0,0 +1,146 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "additionalProperties": false,
+  "title": "prepare-assignment",
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[_a-zA-Z][a-zA-Z0-9_-]*$"
+    },
+    "name": {
+      "description": "Name of the action",
+      "type": "string"
+    },
+    "description": {
+      "description": "Description of what the action does",
+      "type": "string"
+    },
+    "inputs": {
+      "description": "Input parameters passed to the action",
+      "type": "object",
+      "patternProperties": {
+        "^[_a-zA-Z][a-zA-Z0-9_-]*$": {
+          "type": "object",
+          "properties": {
+            "description": {
+              "description": "Description of the input parameter",
+              "type": "string"
+            },
+            "required": {
+              "description": "A boolean to indicate if the input parameter is required",
+              "type": "boolean",
+              "default": false
+            },
+            "default": {
+              "description": "The default value of the input parameter"
+            },
+            "type": {
+              "description": "Type of the default value",
+              "type": "string",
+              "enum": [
+                "string",
+                "number",
+                "integer",
+                "array",
+                "boolean"
+              ],
+              "default": "string"
+            },
+            "items": {
+              "description": "If the default value is an array, specify the type of the items",
+              "type": "string",
+              "enum": [
+                "string",
+                "number",
+                "integer",
+                "boolean"
+              ]
+            }
+          },
+          "allOf": [
+            {
+              "if": {
+                "properties": {
+                  "type": {
+                    "const": "array"
+                  }
+                },
+                "required": [
+                  "type"
+                ]
+              },
+              "then": {
+                "required": [
+                  "description",
+                  "type",
+                  "items"
+                ]
+              },
+              "else": {
+                "required": [
+                  "description"
+                ],
+                "properties": {
+                  "items": {
+                    "not": {}
+                  }
+                }
+              }
+            }
+          ],
+          "additionalProperties": false
+        }
+      }
+    },
+    "runs": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "using": {
+          "type": "string",
+          "enum": [
+            "python",
+            "composite"
+          ]
+        },
+        "main": {
+          "type": "string"
+        },
+        "steps": { "type": "array"}
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": {
+              "using": {
+                "const": "python"
+              }
+            },
+            "required": [
+              "using"
+            ]
+          },
+          "then": {
+            "required": [
+              "using",
+              "main"
+            ]
+          },
+          "else": {
+            "required": [
+              "using",
+              "steps"
+            ]
+          }
+        }
+      ]
+    }
+  },
+  "required": [
+    "id",
+    "name",
+    "description",
+    "runs"
+  ]
+}

prepare_assignment-0.1.0/prepare_assignment/schemas/actions.schema.json_template

@@ -0,0 +1,22 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/{{organization}}/{{action-id}}/{{action-id}}.schema.json",
+  "additionalProperties": false,
+  "title": "{{action-name}}",
+  "description": "{{action-description}}",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "id": {
+      "type": "string"
+    },
+    "uses": {
+      "const": "{{action-id}}"
+    }{{with}}
+  },
+  "required": [
+    "uses"{{required}}
+  ]
+}

prepare_assignment-0.1.0/prepare_assignment/schemas/prepare.schema.json

@@ -0,0 +1,51 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "prepare-assignment",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "steps": {
+      "type": "object",
+        "patternProperties": {
+          "^[_a-zA-Z][a-zA-Z0-9_-]*$": {
+            "type": "array",
+            "items": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "properties": {
+                    "name": {
+                      "type": "string"
+                    },
+                    "uses": {
+                      "type": "string"
+                    }
+                  },
+                  "required": ["name", "uses"]
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "name": {
+                      "type": "string"
+                    },
+                    "run": {
+                      "type": "string"
+                    }
+                  },
+                  "required": ["name", "run"]
+                }
+              ]
+            }
+          }
+        }
+    }
+  },
+  "required": [
+    "name",
+    "steps"
+  ]
+}

prepare_assignment-0.1.0/prepare_assignment/utils/__init__.py

@@ -0,0 +1,3 @@
+from prepare_assignment.utils.cache import get_cache_path
+from prepare_assignment.utils.default_validator import DefaultValidatingValidator
+from prepare_assignment.utils.logger import set_logger_level

prepare_assignment-0.1.0/prepare_assignment/utils/cache.py

@@ -0,0 +1,23 @@
+import os
+import sys
+
+from pathlib import Path
+
+
+def get_cache_path() -> Path:
+    """
+    Get the path to the default cache location for applications
+    :return: Path to the OS specific application cache
+    :raises: AssertionError: if OS is not one of Linux, macOS or Windows
+    """
+    if sys.platform == "linux":
+        cache = os.environ.get("XDG_CACHE_HOME")
+        if cache is None:
+            cache = "~/.cache"
+        return Path(f"{cache}/prepare_assignment").expanduser()
+    elif sys.platform == "darwin":
+        return Path("~/Library/Caches/prepare_assignment").expanduser()
+    elif sys.platform == "win32":
+        lad = f"{os.environ.get('LOCALAPPDATA')}"
+        return Path(os.path.join(lad, "prepare_assignment", "cache"))
+    raise AssertionError("Unsupported OS")

prepare_assignment-0.1.0/prepare_assignment/utils/default_validator.py

@@ -0,0 +1,24 @@
+from jsonschema import validators, Draft7Validator
+
+
+# Adapted from:
+# https://python-jsonschema.readthedocs.io/en/stable/faq/#why-doesn-t-my-schema-s-default-property-set-the-default-on-my-instance
+def extend_with_default(validator_class):
+    validate_properties = validator_class.VALIDATORS["properties"]
+
+    def set_defaults(validator, properties, instance, schema):
+        for property, subschema in properties.items():
+            if "default" in subschema:
+                instance.setdefault(property, subschema["default"])
+
+        for error in validate_properties(
+                validator, properties, instance, schema,
+        ):
+            yield error
+
+    return validators.extend(
+        validator_class, {"properties": set_defaults},
+    )
+
+
+DefaultValidatingValidator = extend_with_default(Draft7Validator)

prepare_assignment-0.1.0/prepare_assignment/utils/logger.py

@@ -0,0 +1,51 @@
+import logging
+from typing import Dict
+
+
+class ColourFormatter(logging.Formatter):
+    """
+    Custom logger that adds color based on level
+    Taken from: https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
+    """
+
+    light_blue = "\x1b[1;34m"
+    grey = "\x1b[38;20m"
+    yellow = "\x1b[33;20m"
+    red = "\x1b[31;20m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format_log_debug = "%(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+    format_log = "%(levelname)s - %(message)s"
+
+    FORMATS: Dict[int, str] = {
+        logging.DEBUG: grey + format_log_debug + reset,
+        logging.INFO: light_blue + format_log + reset,
+        logging.WARNING: yellow + format_log + reset,
+        logging.ERROR: red + format_log + reset,
+        logging.CRITICAL: bold_red + format_log + reset
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+def set_logger_level(logger: logging.Logger, verbosity: int = 0, add_colours: bool = True) -> None:
+    handler = logging.StreamHandler()
+    if add_colours:
+        handler.setFormatter(ColourFormatter())
+    if verbosity == 0:
+        logger.setLevel(logging.ERROR)
+        handler.setLevel(logging.ERROR)
+    elif verbosity == 1:
+        logger.setLevel(logging.WARNING)
+        handler.setLevel(logging.WARNING)
+    elif verbosity == 2:
+        logger.setLevel(logging.INFO)
+        handler.setLevel(logging.INFO)
+    elif verbosity >= 3:
+        logger.setLevel(logging.DEBUG)
+        handler.setLevel(logging.DEBUG)
+    logger.addHandler(handler)
+    logger.propagate = False

prepare_assignment-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "prepare-assignment"
+version = "0.1.0"
+description = "Prepare assignment"
+authors = ["Bonajo <m.bonajo@fontys.nl>"]
+license = "MIT"
+readme = "README.md"
+packages = [{include = "prepare_assignment"}]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.dependencies]
+python = "^3.8"
+ruamel-yaml = "^0.17.21"
+jsonschema = "^4.17.3"
+importlib-resources = "^5.12.0"
+gitpython = "^3.1.31"
+prepare-toolbox = "^0.2.0"
+virtualenv = "^20.24.5"
+
+[tool.poetry.group.test.dependencies]
+mypy = "^1.1.1"
+types-jsonschema = "^4.17.0.6"
+pytest = "^7.4.0"
+pytest-cov = "^4.1.0"