github_custom_actions.ActionBase

class ActionBase:
    """Base class for GitHub Actions.

    You should implement `main()` method in the subclass.

    You can define custom inputs and / or outputs types in the subclass.
    You can do nothing in the subclass if you don't need typed inputs and outputs.

    Note these are just types, instances of these types are automatically created
    in the `__init__` method.

    Usage:
    ```python
    class MyInputs(ActionInputs):
        my_input: str
        '''My input description'''

        my_path: Path
        '''My path description'''

    class MyOutputs(ActionOutputs):
        runner_os: str
        '''Runner OS description'''

    class MyAction(ActionBase):
        inputs: MyInputs
        outputs: MyOutputs

        def main(self):
            if self.inputs.my_path is None:
                raise ValueError("my-path is required")
            self.inputs.my_path.mkdir(exist_ok=True)
            self.outputs.runner_os = self.env.runner_os
            self.summary += (
                self.render(
                    "### {{ inputs.my_input }}.\\n"
                    "Have a nice day, {{ inputs['name'] }}!"
                )
            )

    if __name__ == "__main__":
        MyAction().run()
    ```
    """

    inputs: ActionInputs
    outputs: ActionOutputs
    env: GithubVars

    def __init__(self) -> None:
        """Initialize inputs, outputs according to the type than could be set in subclass."""
        types = get_type_hints(self.__class__)
        self.inputs = types["inputs"]()
        self.outputs = types["outputs"]()
        self.env = GithubVars()

        base_dir = Path(__file__).resolve().parent
        templates_dir = base_dir / "templates"
        self.environment = Environment(  # noqa: S701
            loader=FileSystemLoader(str(templates_dir)),
        )

    summary = FileTextProperty("github_step_summary")

    def main(self) -> None:
        """Business logic of the action.

        Is called by `run()` method.
        """
        raise NotImplementedError

    def run(self) -> None:
        """Run the action.

        `run()` calls the `main()` method of the action with the necessary boilerplate to catch and
        report exceptions.

        Usage:
        ```python
        if __name__ == "__main__":
            MyAction().run()
        ```

        `main()` is where you implement the business logic of your action.
        """
        try:
            self.main()
        except Exception:  # noqa: BLE001
            traceback.print_exc(file=sys.stderr)
            sys.exit(1)

    @staticmethod
    def debug(message: str):
        """
        Emits a debug message. The runner needs to be invoked with enabled debug
        logging to show these.

        Example usage:

        ```python
        self.debug("Action invoked.")
        ```
        """
        print(f"::debug::{message}")

    @staticmethod
    def message(  # noqa: PLR0913
        severity: Literal["error", "notice", "warning"],
        message: str,
        title: Optional[str] = None,
        file: Optional[str] = None,
        line: Optional[int] = None,
        column: Optional[int] = None,
        end_line: Optional[int] = None,
        end_column: Optional[int] = None,
    ):
        """
        Emits a message at the given `severity` level. The keyword arguments can be used
        to generate annotations that will be displayed within the Review section of a
        Pull Request. Refer to the messages related section in the
        [workflows commands reference](https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-commands)
        for semantic details.

        There are also the methods `error_message`, `notice_message` and
        `warning_message` as shortcuts.

        Example usages:

        ```python
        self.message("warning", "Deprecated input used: pattern")
        # or equivalently:
        self.warning_message("Deprecated input used: pattern")

        self.error_message(
            "Value exceeds limit.",
            title="Schema error",
            file="config.yml",
            line=7,
            column=42
        )
        ```

        """
        _locals = locals().copy()
        parameters = ",".join(
            f"{x}={value}"
            for x in ("title", "file", "line", "column", "end_line", "end_column")
            if (value := _locals[x]) is not None
        )
        print(f"::{severity}{(' ' + parameters) if parameters else ''}::{message}")

    error_message = partialmethod(message, "error")
    notice_message = partialmethod(message, "notice")
    warning_message = partialmethod(message, "warning")

    def render(self, template: str, **kwargs: Any) -> str:
        """Render the template from the string with Jinja.

        `kwargs` are the template context variables.

        Also includes to the context the action's `inputs`, `outputs`, and `env`.

        So you can use something like:
        ```python
        self.render("### {{ inputs.name }}!\\nHave a nice day!")
        ```

        """
        return Template(template.replace("\\n", "\n")).render(
            env=self.env,
            inputs=self.inputs,
            outputs=self.outputs,
            **kwargs,
        )

    def render_template(self, template_name: str, **kwargs: Any) -> str:
        """Render template from the `templates` directory.

        `template_name` is the name of the template file without the extension.
        `kwargs` are the template context variables.

        Also includes to the context the action's `inputs`, `outputs`, and `env`.

        Usage:
        ```python
        self.render_template("executor.json", image="ubuntu-latest")
        ```
        """
        template = self.environment.get_template(template_name)
        return template.render(
            env=self.env,
            inputs=self.inputs,
            outputs=self.outputs,
            **kwargs,
        )