cgse-common 2025.0.5__tar.gz → 2025.0.6__tar.gz

{cgse_common-2025.0.5 → cgse_common-2025.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse-common
-Version: 2025.0.5
+Version: 2025.0.6
 Summary: Software framework to support hardware testing
 Author: IVS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

{cgse_common-2025.0.5 → cgse_common-2025.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-common"
-version = "2025.0.5"
+version = "2025.0.6"
 description = "Software framework to support hardware testing"
 authors = [
     {name = "IVS KU Leuven"}
@@ -36,10 +36,13 @@ dependencies = [
 [project.entry-points."cgse.version"]
 cgse-common = 'egse'
 
+[project.entry-points."cgse.settings"]
+cgse-common = "cgse_common:settings.yaml"
+
 [tool.pytest.ini_options]
 pythonpath = "src"
 testpaths = ["tests"]
-addopts = "-ra --cov --cov-report html"
+addopts = "-ra --cov --cov-branch --cov-report html"
 filterwarnings = [
     "ignore::DeprecationWarning"
 ]
@@ -60,7 +63,7 @@ exclude = [
 ]
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/egse"]
+packages = ["src/egse", "src/cgse-common"]
 
 [tool.ruff]
 line-length = 120

{cgse_common-2025.0.5/src/egse → cgse_common-2025.0.6/src/cgse_common}/settings.yaml

@@ -1,5 +1,8 @@
+PACKAGES:
+    CGSE_COMMON: Common classes, functions, decorators, etc. for the CGSE
+
 SITE:
-    ID:                            XXX
+    ID:                           XXXX         # The SITE ID shall be filled in by the local settings file
     SSH_SERVER:              localhost         # The IP address of the SSH server on your site
     SSH_PORT:                       22         # The TCP/IP port on which the SSH server is listening
 

{cgse_common-2025.0.5 → cgse_common-2025.0.6}/src/egse/decorators.py

@@ -10,6 +10,8 @@ import warnings
 from typing import Callable
 from typing import Optional
 
+import rich
+
 from egse.settings import Settings
 from egse.system import get_caller_info
 
@@ -227,7 +229,14 @@ def profile_func(output_file=None, sort_by='cumulative', lines_to_print=None, st
 
 
 def profile(func):
-    """Print the function signature and return value"""
+    """
+    Prints the function signature and return value to stdout.
+
+    This function checks the `Settings.profiling()` value and only prints out
+    profiling information if this returns True.
+
+    Profiling can be activated with `Settings.set_profiling(True)`.
+    """
     if not hasattr(profile, "counter"):
         profile.counter = 0
 
@@ -240,10 +249,10 @@ def profile(func):
             signature = ", ".join(args_repr + kwargs_repr)
             caller = get_caller_info(level=2)
             prefix = f"PROFILE[{profile.counter}]: "
-            _LOGGER.info(f"{prefix}Calling {func.__name__}({signature})")
-            _LOGGER.info(f"{prefix}    from {caller.filename} at {caller.lineno}.")
+            rich.print(f"{prefix}Calling {func.__name__}({signature})")
+            rich.print(f"{prefix}    from {caller.filename} at {caller.lineno}.")
             value = func(*args, **kwargs)
-            _LOGGER.info(f"{prefix}{func.__name__!r} returned {value!r}")
+            rich.print(f"{prefix}{func.__name__!r} returned {value!r}")
             profile.counter -= 1
         else:
             value = func(*args, **kwargs)

{cgse_common-2025.0.5 → cgse_common-2025.0.6}/src/egse/env.py

@@ -47,7 +47,7 @@ __all__ = [
     "get_conf_repo_location_env_name",
     "get_data_storage_location",
     "get_data_storage_location_env_name",
-    "get_local_settings",
+    "get_local_settings_path",
     "get_local_settings_env_name",
     "get_log_file_location",
     "get_log_file_location_env_name",
@@ -455,18 +455,30 @@ def set_local_settings(path: str | Path | None):
     _env.set('LOCAL_SETTINGS', path)
 
 
-def get_local_settings() -> str:
-    """Returns the fully qualified filename of the local settings YAML file."""
+def get_local_settings_path() -> str or None:
+    """
+    Returns the fully qualified filename of the local settings YAML file. When the local settings environment
+    variable is not defined or is an empty string, None is returned.
+
+    Warnings:
+        - When the local settings environment variable is not defined, or
+        - when the path defined by the environment variable doesn't exist.
+    """
 
     local_settings = _env.get("LOCAL_SETTINGS")
 
-    if local_settings and not Path(local_settings).exists():
+    if not local_settings:
+        warnings.warn(f"The local settings environment variable '{get_local_settings_env_name()}' "
+                      f"is not defined or is an empty string.")
+        return None
+
+    if not Path(local_settings).exists():
         warnings.warn(
-            f"The local settings '{local_settings}' doesn't exist. As a result, "
+            f"The local settings path '{local_settings}' doesn't exist. As a result, "
             f"the local settings for your project will not be loaded."
         )
 
-    return local_settings or None
+    return local_settings
 
 
 def has_conf_repo_location() -> bool:
@@ -552,7 +564,7 @@ def print_env():
         console.print(f"  {get_log_file_location_env_name():{col_width}s}: {get_log_file_location()}")
         console.print(f"  {get_conf_data_location_env_name():{col_width}s}: {get_conf_data_location()}")
         console.print(f"  {get_conf_repo_location_env_name():{col_width}s}: {get_conf_repo_location()}")
-        console.print(f"  {get_local_settings_env_name():{col_width}s}: {get_local_settings()}")
+        console.print(f"  {get_local_settings_env_name():{col_width}s}: {get_local_settings_path()}")
 
 
 @contextlib.contextmanager
@@ -726,8 +738,8 @@ def main(args: list | None = None):  # pragma: no cover
             rich.print(f"    get_log_file_location() = [red]{exc}[/]")
 
         try:
-            rich.print(f"    {get_local_settings() = }", flush=True, end="")
-            location = get_local_settings()
+            rich.print(f"    {get_local_settings_path() = }", flush=True, end="")
+            location = get_local_settings_path()
             if location is None or not Path(location).exists():
                 rich.print("  [red]⟶ ERROR: The local settings file is not defined or doesn't exist![/]")
             else:

{cgse_common-2025.0.5 → cgse_common-2025.0.6}/src/egse/plugin.py

@@ -1,34 +1,96 @@
+"""
+This module provides function to load plugins and settings from entry-points.
+"""
+__all__ = [
+    "load_plugins",
+    "get_file_infos",
+    "entry_points",
+]
 import logging
 import os
 import sys
 import textwrap
 import traceback
+from importlib.metadata import EntryPoint
+from pathlib import Path
 
 import click
 import rich
 
-LOGGER = logging.getLogger(__name__)
+_LOGGER = logging.getLogger(__name__)
 
 
-def entry_points(name: str):
+def entry_points(name: str) -> set[EntryPoint]:
+    """
+    Returns a set with all entry-points for the given group name.
+
+    When the name is not known as an entry-point group, an empty set will be returned.
+    """
+
     import importlib.metadata
 
     try:
         x = importlib.metadata.entry_points()[name]
         return {ep for ep in x}  # use of set here to remove duplicates
     except KeyError:
-        return []
+        return set()
 
 
 def load_plugins(entry_point: str) -> dict:
-
+    """
+    Returns a dictionary with plugins loaded. The keys are the names of the entry-points,
+    the values are the loaded modules or objects.
+    """
     eps = {}
     for ep in entry_points(entry_point):
         try:
             eps[ep.name] = ep.load()
         except Exception as exc:
             eps[ep.name] = None
-            LOGGER.error(f"Couldn't load entry point: {exc}")
+            _LOGGER.error(f"Couldn't load entry point: {exc}")
+
+    return eps
+
+
+def get_file_infos(entry_point: str) -> dict[str, tuple[Path, str]]:
+    """
+    Returns a dictionary with location and filename of all the entries found for
+    the given entry-point name.
+
+    The entry-points are interpreted as follows: <name> = "<module>:<filename>" where
+
+    - <name> is the name of the entry-point given in the pyproject.toml file
+    - <module> is a valid module name that can be imported and from which the location can be determined.
+    - <filename> is the name of the target file, e.g. a YAML file
+
+    As an example, for the `cgse-common` settings, the following entry in the `pyproject.toml`:
+
+        [project.entry-points."cgse.settings"]
+        cgse-common = "cgse_common:settings.yaml"
+
+    Note that the module name for this entry point has an underscore instead of a dash.
+
+    Return:
+        A dictionary with the entry point name as the key and a tuple (location, filename) as the value.
+    """
+    from egse.system import get_module_location
+
+    eps = dict()
+
+    for ep in entry_points(entry_point):
+        try:
+            path = get_module_location(ep.module)
+
+            if path is None:
+                _LOGGER.error(
+                    f"The entry-point '{ep.name}' is ill defined. The module part doesn't exist or is a "
+                    f"namespace. No settings are loaded for this entry-point."
+                )
+            else:
+                eps[ep.name] = (path, ep.attr)
+
+        except Exception as exc:
+            _LOGGER.error(f"The entry point '{ep.name}' is ill defined: {exc}")
 
     return eps
 
@@ -77,7 +139,7 @@ class BrokenCommand(click.Command):
         self.help = textwrap.dedent(
             f"""\
             Warning: entry point could not be loaded. Contact its author for help.
-            
+
             {traceback.format_exc()}
             """
         )

{cgse_common-2025.0.5 → cgse_common-2025.0.6}/src/egse/settings.py

@@ -3,9 +3,16 @@ The Settings class handles user and configuration settings that are provided in
 a [`YAML`](http://yaml.org) file.
 
 The idea is that settings are grouped by components or any arbitrary grouping that makes sense for
-the application or for the user. The Settings class can read from different YAML files. By default,
-settings are loaded from a file called ``settings.yaml``. The default yaml configuration file is
-located in the same directory as this module.
+the application or for the user. Settings are also modular and provided by each package by means
+of entry-points.The Settings class can read from different YAML files.
+
+By default, settings are loaded from a file called `settings.yaml`, but this can be changed in the entry-point
+definition.
+
+The yaml configuration files are provided as entry-points by the packages that provided an entry-point
+group 'cgse.settings'. The Settings dictionary (attrdict) is constructed from the configuration YAML
+files from each of the packages. Settings can be overwritten by the next package configuration file.
+So, make sure the group names in each package configuration file are unique.
 
 The YAML file is read and the configuration parameters for the given group are
 available as instance variables of the returned class.
@@ -23,11 +30,10 @@ The intended use is as follows:
     else:
         raise RMAPError("Attempt to access outside the RMAP memory map.")
 
-
-The above code reads the settings from the default YAML file for a group called ``DSI``.
+The above code reads the settings from the default YAML file for a group called `DSI`.
 The settings will then be available as variables of the returned class, in this case
-``dsi_settings``. The returned class is and behaves also like a dictionary, so you can check
-if a configuration parameter is defined like this:
+`dsi_settings`. The returned class is and behaves also like a dictionary, so you can
+check if a configuration parameter is defined like this:
 
     if "DSI_FEE_IP_ADDRESS" not in dsi_settings:
         # define the IP address of the DSI
@@ -46,12 +52,12 @@ The YAML section for the above code looks like this:
         RMAP_BASE_ADDRESS:     0x00000000   # The start of the RMAP memory map managed by the FEE
         RMAP_MEMORY_SIZE:            4096   # The size of the RMAP memory map managed by the FEE
 
-When you want to read settings from another YAML file, specify the ``filename=`` keyword.
-If that file is located at a specific location, also use the ``location=`` keyword.
+When you want to read settings from another YAML file, specify the `filename=` keyword.
+If that file is located at a specific location, also use the `location=` keyword.
 
     my_settings = Settings.load(filename="user.yaml", location="/Users/JohnDoe")
 
-The above code will read the complete YAML file, i.e. all the groups into a dictionary.
+The above code will read the YAML file from the given location and not from the entry-points.
 
 """
 from __future__ import annotations
@@ -63,12 +69,9 @@ from typing import Any
 
 import yaml  # This module is provided by the pip package PyYaml - pip install pyyaml
 
-from egse.env import get_local_settings
 from egse.env import get_local_settings_env_name
-from egse.exceptions import FileIsEmptyError
+from egse.env import get_local_settings_path
 from egse.system import attrdict
-from egse.system import get_package_location
-from egse.system import ignore_m_warning
 from egse.system import recursive_dict_update
 
 _LOGGER = logging.getLogger(__name__)
@@ -80,22 +83,6 @@ class SettingsError(Exception):
     pass
 
 
-def is_defined(cls, name):
-    return hasattr(cls, name)
-
-
-def get_attr_value(cls, name, default=None):
-    try:
-        return getattr(cls, name)
-    except AttributeError:
-        return default
-
-
-def set_attr_value(cls, name, value):
-    if hasattr(cls, name):
-        raise KeyError(f"Overwriting setting {name} with {value}, was {hasattr(cls, name)}")
-
-
 # Fix the problem: YAML loads 5e-6 as string and not a number
 # https://stackoverflow.com/questions/30458977/yaml-loads-5e-6-as-string-and-not-a-number
 
@@ -112,91 +99,117 @@ SAFE_LOADER.add_implicit_resolver(
     list(u'-+0123456789.'))
 
 
-def get_settings_locations(location: str | Path = None, filename: str = "settings.yaml") -> list[Path]:
+def load_settings_file(path: Path, filename: str, force: bool = False) -> attrdict:
+    """
+    Loads the YAML configuration file that is located at `path / filename`.
+
+    Args:
+        - path (PATH): the folder where the YAML file is located
+        - filename (str): the name of the YAML configuration file
+        - force (bool): force reloading, i.e. don't use the cached information
+
+    Raises:
+        A SettingsError when the configuration file doesn't exist or cannot be found.
 
-    yaml_locations: set[Path] = set()
+        A SettingsError when there was an error reading the configuration file.
 
-    if location is None:
-        package_locations = get_package_location("egse")  # `egse` is a namespace
+    Returns:
+         A dictionary (attrdict) with all the settings from the given file.
 
-        for package_location in package_locations:
-            if (package_location / filename).exists():
-                yaml_locations.add(package_location)
+         Note that, in case of an empty configuration file, and empty dictionary
+         is returned and a warning message is issued.
+    """
+    try:
+        yaml_document = read_configuration_file(path / filename, force=force)
+        settings = attrdict(
+            {name: value for name, value in yaml_document.items()}
+        )
+    except FileNotFoundError as exc:
+        raise SettingsError(
+            f"The Settings YAML file '{filename}' is not found at {path!s}. "
+        ) from exc
 
-        yaml_locations.add(_HERE)
-        _LOGGER.debug(f"yaml_locations in Settings.load():  {yaml_locations}")
+    if not settings:
+        _LOGGER.warning(
+            f"The Settings YAML file '{filename}' at {path!s} is empty. "
+            f"No local settings were loaded, an empty dictionary is returned.")
 
-    else:
+    return settings
 
-        package_location = Path(location).resolve()
-        if (package_location / filename).exists():
-            yaml_locations.add(package_location)
-        else:
-            _LOGGER.warning(f"No '{filename}' file found at {package_location}.")
 
-    return list(yaml_locations)
+def load_global_settings(entry_point: str = 'cgse.settings', force: bool = False) -> attrdict:
+    """
+    Loads the settings that are defined by the given entry_point. The entry-points are defined in the
+    `pyproject.toml` files of the packages that export their global settings.
 
+    Args:
+         - entry_point (str): the name of the entry-point group [default: 'cgse.settings']
+         - force (bool): force reloading the settings, i.e. ignore the cache
 
-def load_global_settings(locations, filename: str = "settings.yaml", force: bool = False) -> attrdict:
+    Returns:
+        A dictionary (attrdict) containing a collection of all the settings exported by the packages
+        through the given entry-point.
 
-    global_settings = attrdict()
+    """
+    from egse.plugin import get_file_infos
 
-    for yaml_location in locations:
-        try:
-            yaml_document = read_configuration_file(str(yaml_location / filename), force=force)
-            recursive_dict_update(global_settings, yaml_document)
-        except FileNotFoundError as exc:
-            raise SettingsError(
-                f"Filename {filename} not found at location {locations}."
-            ) from exc
+    ep_settings = get_file_infos(entry_point)
+
+    global_settings = attrdict(label="Settings")
+
+    for ep_name, (path, filename) in ep_settings.items():
+        settings = load_settings_file(path, filename, force)
+        recursive_dict_update(global_settings, settings)
 
     return global_settings
 
 
-def load_local_settings(force: bool = False):
+def load_local_settings(force: bool = False) -> attrdict:
+    """
+    Loads the local settings file that is defined from the environment variable <PROJECT>_LOCAL_SETTINGS.
+
+    This function might return an empty dictionary when
 
-    local_settings = {}
-    try:
-        local_settings_location = get_local_settings()
+      - the local settings YAML file is empty
+      - the local settings environment variable is not defined.
 
-        if local_settings_location:
-            _LOGGER.debug(f"Using {local_settings_location} to update global settings.")
-            try:
-                yaml_document_local = read_configuration_file(local_settings_location, force=force)
-                if yaml_document_local is None:
-                    raise FileIsEmptyError()
-                local_settings = attrdict(
-                    {name: value for name, value in yaml_document_local.items()}
-                )
-            except FileNotFoundError as exc:
-                raise SettingsError(
-                    f"Local settings YAML file '{local_settings_location}' not found. "
-                    f"Check your environment variable {get_local_settings_env_name()}."
-                ) from exc
-            except FileIsEmptyError:
-                _LOGGER.warning(
-                    f"Local settings YAML file '{local_settings_location}' is empty. "
-                    f"No local settings were loaded.")
-
-    except KeyError as exc:
-        _LOGGER.warning(f"The environment variable {get_local_settings_env_name()} is not defined. (from "
-                        f"{exc.__class__.__name__}: {exc})")
+    in both cases a warning message is logged.
+
+    Returns:
+        A dictionary (attrdict) with all local settings.
+
+    Raises:
+        A SettingsError when the local settings YAML file is not found. Check the <PROJECT>_LOCAL_SETTINGS
+        environment variable.
+    """
+    local_settings = attrdict()
+
+    local_settings_path = get_local_settings_path()
+
+    if local_settings_path:
+        path = Path(local_settings_path)
+        local_settings = load_settings_file(path.parent, path.name, force)
 
     return local_settings
 
 
-def read_configuration_file(filename: str, *, force=False):
+def read_configuration_file(filename: Path, *, force=False):
     """
     Read the YAML input configuration file. The configuration file is only read
     once and memoized as load optimization.
 
     Args:
-        filename (str): the fully qualified filename of the YAML file
-        force (bool): force reloading the file
+        filename (Path): the fully qualified filename of the YAML file
+        force (bool): force reloading the file, even when it was memoized
+
+    Raises:
+        A SettingsError when there was an error reading the YAML file.
 
     Returns:
         a dictionary containing all the configuration settings from the YAML file.
     """
+    filename = str(filename)
+
     if force or not Settings.is_memoized(filename):
 
         _LOGGER.debug(f"Parsing YAML configuration file {filename}.")
@@ -261,94 +274,95 @@ class Settings:
     def profiling(cls):
         return cls.__profile
 
-    @classmethod
-    def load(cls, group_name=None, filename="settings.yaml", location=None, *, force=False, add_local_settings=True):
+    @staticmethod
+    def _load_all(
+            entry_point: str = 'cgse.settings',
+            add_local_settings: bool = False,
+            force: bool = False
+    ) -> attrdict:
         """
-        Load the settings for the given group from YAML configuration file.
-        When no group is provided, the complete configuration is returned.
-
-        The default YAML file is 'settings.yaml' and is located in the same directory
-        as the settings module.
-
-        About the ``location`` keyword several options are available.
-
-        * when no location is given, i.e. ``location=None``, the YAML settings file is searched for
-          at the same location as the settings module.
-
-        * when a relative location is given, the YAML settings file is searched for relative to the
-          current working directory.
-
-        * when an absolute location is given, that location is used 'as is'.
+        Loads all settings from all package with the entry point 'cgse.settings'
+        """
+        global_settings = load_global_settings(entry_point, force)
 
-        Args:
-            group_name (str): the name of one of the main groups from the YAML file
-            filename (str): the name of the YAML file to read
-            location (str, Path): the path to the location of the YAML file
-            force (bool): force reloading the file
-            add_local_settings (bool): update the Settings with site specific local settings
+        # Load the LOCAL settings YAML file
 
-        Returns:
-            a dynamically created class with the configuration parameters as instance variables.
+        if add_local_settings:
+            local_settings = load_local_settings(force)
+            recursive_dict_update(global_settings, local_settings)
 
-        Raises:
-            a SettingsError when the group is not defined in the YAML file.
-        """
+        return global_settings
 
-        # Load all detected YAML documents, these are considered global settings
+    @staticmethod
+    def _load_group(
+            group_name: str,
+            entry_point: str = 'cgse.settings',
+            add_local_settings: bool = False,
+            force: bool = False
+    ) -> attrdict:
 
-        yaml_locations = get_settings_locations(location, filename)
-        global_settings = load_global_settings(yaml_locations, filename, force)
+        global_settings = load_global_settings(entry_point, force)
 
-        if not global_settings:
-            raise SettingsError(f"There were no global settings defined for {filename} at {yaml_locations}.")
+        group_settings = attrdict(label=group_name)
 
-        # Load the LOCAL settings YAML file
+        if group_name in global_settings:
+            group_settings = attrdict(
+                {name: value for name, value in global_settings[group_name].items()},
+                label=group_name
+            )
 
         if add_local_settings:
             local_settings = load_local_settings(force)
-        else:
-            local_settings = {}
-
-        if group_name in (None, ""):
-            global_settings = attrdict(
-                {name: value for name, value in global_settings.items()},
-                label="Settings"
-            )
-            if add_local_settings:
-                recursive_dict_update(global_settings, local_settings)
-            return global_settings
-
-        if group_name in global_settings:
-            include_global_settings = True
-        else:
-            include_global_settings = False
-        if group_name in local_settings:
-            include_local_settings = True
-        else:
-            include_local_settings = False
+            if group_name in local_settings:
+                recursive_dict_update(group_settings, local_settings[group_name])
 
-        if not include_global_settings and not include_local_settings:
+        if not group_settings:
             raise SettingsError(
                 f"Group name '{group_name}' is not defined in the global nor in the local settings."
             )
 
-        # Check if the group has any settings
+        return group_settings
 
-        if include_global_settings and not global_settings[group_name]:
-            _LOGGER.warning(f"Empty group in YAML document {filename} for {group_name}.")
+    @staticmethod
+    def _load_one(location: str, filename: str, force=False) -> attrdict:
 
-        if include_global_settings:
-            group_settings = attrdict(
-                {name: value for name, value in global_settings[group_name].items()},
-                label=group_name
-            )
-        else:
-            group_settings = attrdict(label=group_name)
+        return load_settings_file(Path(location).expanduser(), filename, force)
+
+    @classmethod
+    def load(
+            cls,
+            group_name=None, filename="settings.yaml", location=None,
+            *, add_local_settings=True, force=False
+    ):
+        """
+        Load the settings for the given group. When no group is provided, the
+        complete configuration is returned.
 
-        if add_local_settings and include_local_settings:
-            recursive_dict_update(group_settings, local_settings[group_name])
+        The Settings are loaded from entry-points that are defined in each of the
+        packages that provide a Settings file.
 
-        return group_settings
+        If a location is explicitly provided, the Settings will be loaded from that
+        location, using the given filename or the default (which is settings.yaml).
+
+        Args:
+            group_name (str): the name of one of the main groups from the YAML file
+            filename (str): the name of the YAML file to read [default=settings.yaml]
+            location (str, Path): the path to the location of the YAML file
+            force (bool): force reloading the file
+            add_local_settings (bool): update the Settings with site specific local settings
+
+        Returns:
+            a dynamically created class with the configuration parameters as instance variables.
+
+        Raises:
+            a SettingsError when the group is not defined in the YAML file.
+        """
+        if group_name:
+            return cls._load_group(group_name, add_local_settings=add_local_settings, force=force)
+        elif location:
+            return cls._load_one(location=location, filename=filename, force=force)
+        else:
+            return cls._load_all(add_local_settings=add_local_settings, force=force)
 
     @classmethod
     def to_string(cls):
@@ -400,7 +414,7 @@ def main(args: list | None = None):  # pragma: no cover
     from rich import print
 
     if args.local:
-        location = get_local_settings()
+        location = get_local_settings_path()
         if location:
             location = str(Path(location).expanduser().resolve())
             settings = Settings.load(filename=location)

cgse_common-2025.0.6/src/egse/settings.yaml

@@ -0,0 +1,5 @@
+# This is a stub file. Don't add any settings to this file, use the settings.yaml file
+# in your projects module, like e.g. `cgse_common/settings.yaml` for this module.
+
+SITE:
+    ID:  XXXX

{cgse_common-2025.0.5 → cgse_common-2025.0.6}/src/egse/setup.py

@@ -120,6 +120,7 @@ import logging
 import os
 import re
 import textwrap
+import warnings
 from functools import lru_cache
 from pathlib import Path
 from typing import Any
@@ -130,13 +131,14 @@ import rich
 import yaml
 from rich.tree import Tree
 
+from egse.env import get_conf_data_location
 from egse.env import get_conf_repo_location
 from egse.env import get_conf_repo_location_env_name
 from egse.env import get_data_storage_location
 from egse.env import has_conf_repo_location
 from egse.env import print_env
 from egse.response import Failure
-from egse.env import get_conf_data_location
+from egse.settings import read_configuration_file
 from egse.system import format_datetime
 from egse.system import sanity_check
 from egse.system import walk_dict_tree
@@ -220,8 +222,8 @@ def _load_yaml(resource_name: str):
     [in_dir, fn] = parts if len(parts) > 1 else [None, parts[0]]
     conf_location = get_conf_data_location()
     try:
-        yaml_location = Path(conf_location) / in_dir / fn
-        content = NavigableDict(Settings.load(filename=yaml_location, add_local_settings=False))
+        yaml_location = Path(conf_location) / in_dir
+        content = NavigableDict(Settings.load(location=yaml_location, filename=fn, add_local_settings=False))
     except (TypeError, SettingsError) as exc:
         raise ValueError(
             f"Couldn't load resource '{resource_name}' from default {conf_location=}") from exc
@@ -695,14 +697,20 @@ class Setup(NavigableDict):
         Returns:
             a Setup that was loaded from the given location.
         """
-        from egse.settings import Settings
 
         if not filename:
             raise ValueError("Invalid argument to function: No filename or None given.")
 
         # MODULE_LOGGER.info(f"Loading {filename}...")
 
-        setup_dict = Settings.load("Setup", filename=filename, force=True, add_local_settings=add_local_settings)
+        setup_dict = read_configuration_file(filename, force=True)
+        if setup_dict == {}:
+            warnings.warn(f"Empty Setup file: {filename!s}")
+
+        try:
+            setup_dict = setup_dict["Setup"]
+        except KeyError:
+            warnings.warn(f"Setup file doesn't have a 'Setup' group: {filename!s}")
 
         setup = Setup(setup_dict, label="Setup")
         setup.set_private_attribute("_filename", filename)