_get_global_path_specs source

        
def _get_global_path_specs(tool: str) -> path_spec_type:
    """
    Generate a list of standard pathspecs for global config files.

    Args:
        tool (str): name of the tool to configure
    """
    try:
        home = Path(os.environ["XDG_HOME"])
    except KeyError:
        home = Path.home()

    return [
        {"path_specs": home / f"{tool}.ini", "parser": "ini", "keys": [tool]},
        {"path_specs": home / f".{tool}", "parser": "ini", "keys": [tool]},
        {"path_specs": home / f".{tool}.ini", "parser": "ini", "keys": [tool]},
        {
            "path_specs": home / ".config" / f"{tool}.ini",
            "parser": "ini",
            "keys": [tool],
        },
        {
            "path_specs": home / ".config" / f".{tool}",
            "parser": "ini",
            "keys": [tool],
        },
        {
            "path_specs": home / ".config" / f".{tool}.ini",
            "parser": "ini",
            "keys": [tool],
        },
    ]

_get_local_path_specs source

        
def _get_local_path_specs(tool: str, project_home: Union[str, Path]) -> path_spec_type:
    """
    Generate a list of standard pathspecs for local, project directory config files.

    Args:
        tool (str): name of the tool to configure
    """
    return [
        {
            "path_specs": Path(project_home) / f"{tool}.ini",
            "parser": "ini",
            "keys": [tool],
        },
        {
            "path_specs": Path(project_home) / f".{tool}",
            "parser": "ini",
            "keys": [tool],
        },
        {
            "path_specs": Path(project_home) / f".{tool}.ini",
            "parser": "ini",
            "keys": [tool],
        },
        {
            "path_specs": Path(project_home) / f"{tool}.yml",
            "parser": "yaml",
            "keys": [tool],
        },
        {
            "path_specs": Path(project_home) / f".{tool}.yml",
            "parser": "yaml",
            "keys": [tool],
        },
        {
            "path_specs": Path(project_home) / f"{tool}.toml",
            "parser": "toml",
            "keys": [tool],
        },
        {
            "path_specs": Path(project_home) / f".{tool}.toml",
            "parser": "toml",
            "keys": [tool],
        },
        {
            "path_specs": Path(project_home) / "pyproject.toml",
            "parser": "toml",
            "keys": ["tool", tool],
        },
        {
            "path_specs": Path(project_home) / "setup.cfg",
            "parser": "ini",
            "keys": [f"tool.{tool}"],
        },
    ]

_get_attrs source

        
def _get_attrs(attrs: list, config: Dict) -> Dict:
    """Get nested config data from a list of keys.

    specifically written for pyproject.toml which needs to get `tool` then `<tool>`
    """
    for attr in attrs:
        config = config[attr]
    return config

_load_config_file source

        
def _load_config_file(file_spec: Dict[str, Any]) -> Optional[Dict[str, Any]]:
    """Load a configuration file using the appropriate parser.

    Args:
        file_spec: Dictionary containing path_specs, parser, and keys information

    Returns:
        Optional[Dict[str, Any]]: Parsed configuration or None if file doesn't exist
    """
    path = file_spec["path_specs"]
    if not path.exists():
        return None

    try:
        if file_spec["parser"] == "toml":
            with open(path, "rb") as f:
                config = tomli.load(f)
        elif file_spec["parser"] == "yaml":
            with open(path, "r") as f:
                config = yaml.safe_load(f)
        elif file_spec["parser"] == "ini":
            config = configparser.ConfigParser()
            config.read(path)
            # Convert ConfigParser to dict
            config = {s: dict(config.items(s)) for s in config.sections()}
        else:
            return None

        return _get_attrs(file_spec["keys"], config)
    except (
        KeyError,
        TypeError,
        yaml.YAMLError,
        tomli.TOMLDecodeError,
        configparser.Error,
    ):
        return None

_load_files source

        
def _load_files(config_path_specs: path_spec_type) -> Dict[str, Any]:
    """Load config files stopping at the first one that exists and can be parsed.

    Args:
        config_path_specs: List of path specifications to try

    Returns:
        Dict[str, Any]: Configuration dictionary
    """
    for file_spec in config_path_specs:
        config = _load_config_file(file_spec)
        if config:
            return config
    return {}

_load_env source

        
def _load_env(tool: str) -> Dict[str, Any]:
    """Load config from environment variables.

    Args:
        tool (str): name of the tool to configure
    """
    env_prefix = tool.upper()
    env_config = {
        key.replace(f"{env_prefix}_", "").lower(): value
        for key, value in os.environ.items()
        if key.startswith(f"{env_prefix}_")
    }
    return env_config

load source

        
def load(
    tool: str,
    project_home: Union[Path, str] = ".",
    overrides: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
    """Load tool config from standard config files.

    Resolution Order

    * First global file with a tool key
    * First local file with a tool key
    * Environment variables prefixed with `TOOL`
    * Overrides

    Args:
        tool (str): name of the tool to configure
        project_home (Union[Path, str], optional): Project directory to search for config files. Defaults to ".".
        overrides (Dict, optional): Override values to apply last. Defaults to None.

    Returns:
        Dict[str, Any]: Configuration object
    """
    overrides = overrides or {}
    config = {}

    # Load from files in order of precedence
    config.update(_load_files(_get_global_path_specs(tool)) or {})
    config.update(_load_files(_get_local_path_specs(tool, project_home)) or {})
    config.update(_load_env(tool))
    config.update(overrides)

    # If no settings class is provided, return the raw dict
    return config