Update documentation of hooks LIFO order

RELEASE.md

@@ -14,6 +14,7 @@
 * Updated dataset factories to resolve nested catalog config properly.
 
 ## Documentation changes
+* Added documentation to clarify execution orders of hooks.
 ## Breaking changes to the API
 ## Upcoming deprecations for Kedro 0.19.0
 

docs/source/extend_kedro/plugins.md

@@ -29,8 +29,15 @@ def to_json(metadata):
     pipeline = pipelines["__default__"]
     print(pipeline.to_json())
 ```
+Starting from 0.18.14, Kedro switch to replace `setup.py` with `pyproject.toml`. The plugin need to provide the entry points in either file.
 
-The plugin provides the following `entry_points` config in `setup.py`:
+To use `pyproject.toml`, specifiy
+```toml
+[project.entry-points."kedro.project_commands"]
+kedrojson = kedrojson.plugin.commands
+```
+
+To use `setup.py`, the plugin need to provide the following `entry_points` config in `setup.py`:
 
 ```python
 setup(
@@ -81,6 +88,13 @@ setup(
 )
 ```
 
+Alternatively, to use `pyproject.toml`, you need to register the specifications as follow:
+
+```toml
+[project.entry-points."kedro.starters"]
+starter = plugin.starters
+```
+
 After that you can use this starter with `kedro new --starter=test_plugin_starter`.
 
 ```{note}
@@ -127,7 +141,17 @@ We use the following command convention: `kedro <plugin-name> <command>`, with `
 
 ## Hooks
 
-You can develop hook implementations and have them automatically registered to the project context when the plugin is installed. To enable this for your custom plugin, simply add the following entry in your `setup.py`:
+You can develop hook implementations and have them automatically registered to the project context when the plugin is installed.
+
+To enable this for your custom plugin, simply add the following entry in your `pyproject.toml`
+
+To use `pyproject.toml`, specifiy
+```toml
+[project.entry-points."kedro.hooks"]
+plugin_name = plugin_name.plugin.hooks
+```
+
+If you prefer to use `setup.py`:
 
 ```python
 setup(entry_points={"kedro.hooks": ["plugin_name = plugin_name.plugin:hooks"]})
@@ -162,6 +186,12 @@ You can also develop hook implementations to extend Kedro's CLI behaviour in you
 setup(entry_points={"kedro.cli_hooks": ["plugin_name = plugin_name.plugin:cli_hooks"]})
 ```
 
+Alternatively, to use `pyproject.toml`
+```toml
+[project.entry-points."kedro.cli_hooks"]
+plugin_name = plugin_name.plugin.cli_hooks
+```
+
 where `plugin.py` is the module where you declare hook implementations:
 
 ```python
@@ -204,28 +234,17 @@ connectors are implementations of the `AbstractDataset`
 
 ## Community-developed plugins
 
-See the full list of plugins using the GitHub tag [kedro-plugin](https://github.com/topics/kedro-plugin).
+See the full list of plugins using the GitHub repository [awesome-kedro](https://github.com/kedro-org/awesome-kedro?tab=readme-ov-file#kedro-plugins).
 
 
 ```{note}
 Your plugin needs to have an [Apache 2.0 compatible license](https://www.apache.org/legal/resolved.html#category-a) to be considered for this list.
 ```
 
-- [Kedro-Pandas-Profiling](https://github.com/BrickFrog/kedro-pandas-profiling), by [Justin Malloy](https://github.com/BrickFrog), uses [Pandas Profiling](https://github.com/pandas-profiling/pandas-profiling) to profile datasets in the Kedro catalog
-- [find-kedro](https://github.com/WaylonWalker/find-kedro), by [Waylon Walker](https://github.com/WaylonWalker), automatically constructs pipelines using `pytest`-style pattern matching
-- [kedro-static-viz](https://github.com/WaylonWalker/kedro-static-viz), by [Waylon Walker](https://github.com/WaylonWalker), generates a static [Kedro-Viz](https://github.com/kedro-org/kedro-viz) site (HTML, CSS, JS)
-- [steel-toes](https://github.com/WaylonWalker/steel-toes), by [Waylon Walker](https://github.com/WaylonWalker), prevents stepping on toes by automatically branching data paths
-- [kedro-wings](https://github.com/tamsanh/kedro-wings), by [Tam-Sanh Nguyen](https://github.com/tamsanh), simplifies and speeds up pipeline creation by auto-generating catalog datasets
-- [kedro-great](https://github.com/tamsanh/kedro-great), by [Tam-Sanh Nguyen](https://github.com/tamsanh), integrates Kedro with [Great Expectations](https://greatexpectations.io), enabling catalog-based expectation generation and data validation on pipeline run
-- [Kedro-Accelerator](https://github.com/deepyaman/kedro-accelerator), by [Deepyaman Datta](https://github.com/deepyaman), speeds up pipelines by parallelizing I/O in the background
-- [kedro-dataframe-dropin](https://github.com/mzjp2/kedro-dataframe-dropin), by [Zain Patel](https://github.com/mzjp2), lets you swap out pandas datasets for modin or RAPIDs equivalents for specialised use to speed up your workflows (e.g on GPUs)
 - [kedro-mlflow](https://github.com/Galileo-Galilei/kedro-mlflow), by [Yolan Honoré-Rougé](https://github.com/galileo-galilei) and [Takieddine Kadiri](https://github.com/takikadiri), facilitates [MLflow](https://www.mlflow.org/) integration within a Kedro project. Its main features are modular configuration, automatic parameters tracking, datasets versioning, Kedro pipelines packaging and serving and automatic synchronization between training and inference pipelines for high reproducibility of machine learning experiments and ease of deployment. A tutorial is provided in the [kedro-mlflow-tutorial repo](https://github.com/Galileo-Galilei/kedro-mlflow-tutorial). You can find more information in the [kedro-mlflow documentation](https://kedro-mlflow.readthedocs.io/en/stable/).
-- [Kedro-Neptune](https://github.com/neptune-ai/kedro-neptune), by [Jakub Czakon](https://github.com/jakubczakon) and [Rafał Jankowski](https://github.com/Raalsky), lets you have all the benefits of a nicely organized Kedro pipeline with Neptune: a powerful user interface built for ML metadata management. It lets you browse and filter pipeline executions, compare nodes and pipelines on metrics and parameters, and visualize pipeline metadata like learning curves, node outputs, and charts. For more information, tutorials and videos, go to the [Kedro-Neptune documentation](https://docs.neptune.ai/integrations-and-supported-tools/automation-pipelines/kedro).
-- [kedro-dolt](https://www.dolthub.com/blog/2021-06-16-kedro-dolt-plugin/), by [Max Hoffman](https://github.com/max-hoffman) and [Oscar Batori](https://github.com/oscarbatori), allows you to expand the data versioning abilities of data scientists and engineers
 - [kedro-kubeflow](https://github.com/getindata/kedro-kubeflow), by [GetInData](https://github.com/getindata), lets you run and schedule pipelines on Kubernetes clusters using [Kubeflow Pipelines](https://www.kubeflow.org/docs/components/pipelines/overview/)
 - [kedro-airflow-k8s](https://github.com/getindata/kedro-airflow-k8s), by [GetInData](https://github.com/getindata), enables running a Kedro pipeline with Airflow on a Kubernetes cluster
 - [kedro-vertexai](https://github.com/getindata/kedro-vertexai), by [GetInData](https://github.com/getindata), enables running a Kedro pipeline with Vertex AI Pipelines service
 - [kedro-azureml](https://github.com/getindata/kedro-azureml), by [GetInData](https://github.com/getindata), enables running a Kedro pipeline with Azure ML Pipelines service
 - [kedro-sagemaker](https://github.com/getindata/kedro-sagemaker), by [GetInData](https://github.com/getindata), enables running a Kedro pipeline with Amazon SageMaker service
 - [kedro-partitioned](https://github.com/ProjetaAi/kedro-partitioned), by [Gabriel Daiha Alves](https://github.com/gabrieldaiha) and [Nickolas da Rocha Machado](https://github.com/nickolasrm), extends the functionality on processing partitioned data.
-- [kedro-auto-catalog](https://github.com/WaylonWalker/kedro-auto-catalog), by [Waylon Walker](https://github.com/WaylonWalker) A configurable replacement for `kedro catalog create` that allows you to create default dataset types other than MemoryDataset.

docs/source/hooks/introduction.md

@@ -113,6 +113,9 @@ Kedro also has auto-discovery enabled by default. This means that any installed
 Auto-discovered Hooks will run *first*, followed by the ones specified in `settings.py`.
 ```
 
+#### Auto-registered Hook with Plugin
+You can make your hook auto-registered (pip-installable) by creating a [Kedro plugin](https://docs.kedro.org/en/stable/extend_kedro/plugins.html#hooks). Kedro provides `kedro.hooks` entrypoints to extend this easily.
+
 
 #### Disable auto-registered plugins' Hooks
 
@@ -126,6 +129,18 @@ DISABLE_HOOKS_FOR_PLUGINS = ("<plugin_name>",)
 
 where `<plugin_name>` is the name of an installed plugin for which the auto-registered Hooks must be disabled.
 
+### Hook Execution Order
+Hooks follow a Last-In-First-Out (LIFO) order, which means the first registered hook will be exeucted last.
+
+Hooks are registered in the following order:
+1. Project hooks in `settings.py` - If you have `HOOKS = (hook_a, hookb,)`, `hook_b` will be executed before `hook_a`.
+2. Plugins hooks registered in `kedro.hooks`, and it follows alphabetical order.
+
+In general, hook execution order are not guaranteed and you shouldn't rely on it. If you need to make sure some hook get executed first/last, you can use the the [`tryfirst` or `trylast` argument](https://pluggy.readthedocs.io/en/stable/index.html#call-time-order) for `hook_impl`.
+
 ## Under the hood
 
 Under the hood, we use [pytest's pluggy](https://pluggy.readthedocs.io/en/latest/) to implement Kedro's Hook mechanism. We recommend reading their documentation if you have more questions about the underlying implementation.
+
+### Plugin Hooks
+Plugin hooks are registered using []`importlib_metadata`'s `EntryPoints` API](https://docs.python.org/3/library/importlib.metadata.html)

kedro/templates/project/{{ cookiecutter.repo_name }}/src/pyproject.toml

@@ -27,5 +27,9 @@ docs = [
     "myst-parser~=0.17.2",
 ]
 
+[project.entry-points."kedro.hooks"]
+
 [tool.setuptools.dynamic]
 dependencies = {file = "requirements.txt"}
+
+

kedro/templates/project/{{ cookiecutter.repo_name }}/src/{{ cookiecutter.python_package }}/settings.py

@@ -5,6 +5,7 @@
 # Instantiated project hooks.
 # For example, after creating a hooks.py and defining a ProjectHooks class there, do
 # from {{cookiecutter.python_package}}.hooks import ProjectHooks
+# Hooks are executed in a Last-In-First-Out (LIFO) order.
 # HOOKS = (ProjectHooks(),)
 
 # Installed plugins for which to disable hook auto-registration.