Project Configuration API Reference

PACKAGE_NAME: str  # Current project's package name
settings: LazySettings  # Project settings from settings.py
pipelines: MutableMapping[str, Pipeline]  # Lazy-loaded project pipelines
LOGGING: ProjectLogging  # Project-level logging configuration

class _ProjectSettings:
    """
    Internal class defining all available project settings.
    These can be overridden in your project's settings.py file.
    """

    CONF_SOURCE: str
    """Path to configuration directory. Default: "conf" """

    HOOKS: tuple[Any, ...]
    """Tuple of hook instances to be registered. Default: () """

    CONTEXT_CLASS: type[KedroContext]
    """Custom KedroContext class. Default: KedroContext"""

    SESSION_STORE_CLASS: type[BaseSessionStore]
    """Custom session store class for persisting session data. Default: BaseSessionStore"""

    SESSION_STORE_ARGS: dict[str, Any]
    """Arguments passed to SESSION_STORE_CLASS constructor. Default: {}"""

    DISABLE_HOOKS_FOR_PLUGINS: tuple[str, ...]
    """
    Tuple of plugin names for which hooks should be disabled.
    Default: ()
    Example: ("kedro-viz", "kedro-mlflow")
    """

    CONFIG_LOADER_CLASS: type[AbstractConfigLoader]
    """Custom configuration loader class. Default: OmegaConfigLoader"""

    CONFIG_LOADER_ARGS: dict[str, Any]
    """
    Arguments passed to CONFIG_LOADER_CLASS constructor.
    Default: {}
    Example: {"config_patterns": {"parameters": ["parameters*"]}}
    """

    DATA_CATALOG_CLASS: type[DataCatalog]
    """Custom data catalog class. Default: DataCatalog"""

def configure_project(package_name: str) -> None:
    """
    Configure Kedro project by populating settings and pipelines.

    Parameters:
    - package_name: Python package name of the project
    """

def validate_settings() -> None:
    """
    Eagerly validate that settings module is importable.

    Raises:
    ImportError: If settings module cannot be imported
    ValidationError: If settings are invalid
    """

def find_pipelines() -> dict[str, Pipeline]:
    """
    Automatically find modular pipelines.

    Returns:
    Dictionary mapping pipeline names to Pipeline instances
    """

def configure_logging(logging_config: dict[str, Any]) -> None:
    """
    Configure project logging from logging configuration dictionary.

    Parameters:
    - logging_config: Dictionary containing logging configuration
      (typically from conf/logging.yml)

    Example:
    >>> logging_config = {
    ...     'version': 1,
    ...     'handlers': {
    ...         'rich': {
    ...             'class': 'kedro.logging.RichHandler'
    ...         }
    ...     },
    ...     'root': {
    ...         'level': 'INFO',
    ...         'handlers': ['rich']
    ...     }
    ... }
    >>> configure_logging(logging_config)
    """

from kedro.framework import project

# Configure project (usually done automatically)
project.configure_project("my_project")

# Access package name
print(project.PACKAGE_NAME)

# Access project settings
hooks = project.settings.HOOKS

# Access pipelines
all_pipelines = dict(project.pipelines)
data_pipeline = project.pipelines["data_processing"]

# Configure logging
logging_config = {
    'version': 1,
    'handlers': {
        'rich': {
            'class': 'kedro.logging.RichHandler',
            'rich_tracebacks': True
        }
    },
    'root': {
        'level': 'INFO',
        'handlers': ['rich']
    }
}
project.configure_logging(logging_config)

from my_project.hooks import ProjectHooks

HOOKS = (ProjectHooks(),)
CONF_SOURCE = "conf"