dogtail 2.0.dev10__tar.gz → 2.0.dev11__tar.gz

{dogtail-2.0.dev10 → dogtail-2.0.dev11}/CHANGES

@@ -1,4 +1,4 @@
-2024-10-29 Michal Odehnal <modehnal@redhat.com>
+2025-10-29 Michal Odehnal <modehnal@redhat.com>
 
 	dogtail 2.0.dev2
 	================

{dogtail-2.0.dev10 → dogtail-2.0.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dogtail
-Version: 2.0.dev10
+Version: 2.0.dev11
 Summary: GUI test tool and automation framework that uses Accessibility (AT-SPI) technologies to communicate with desktop applications.
 Author-email: Zack Cerza <zcerza@redhat.com>, Ed Rousseau <rousseau@redhat.com>, David Malcolm <dmalcolm@redhat.com>, Vitezslav Humpa <vhumpa@redhat.com>, Michal Odehnal <modehnal@redhat.com>
 License-Expression: GPL-2.0

{dogtail-2.0.dev10 → dogtail-2.0.dev11}/dogtail/config.ini

@@ -47,5 +47,3 @@ check_for_a11y = True
 
 [user_config]
 user_value_x = user_value_x
-user_value_y = user_value_y
-user_value_z = user_value_z

dogtail-2.0.dev11/dogtail/config.py

@@ -0,0 +1,315 @@
+#!/usr/bin/python3
+"""
+Experimental dogtail changes for 2.0 release.
+"""
+
+# pylint: disable=line-too-long
+# ruff: noqa: E501
+
+import configparser
+
+from typing import get_origin, get_args
+
+import copy
+
+from dogtail.logging import logging_class
+LOGGING = logging_class.logger
+
+
+YES_VALUES = ["y", "yes", "t", "true", "True", "1"]
+NO_VALUES = ["", "n", "no", "f", "false", "False", "0"]
+
+
+CONFIG_SCHEMA = {
+    "config": {
+        "action_delay": ([float, int], 1),
+        "typing_delay": ([float, int], 0.1),
+        "default_delay":([float, int], 0.5),
+        "double_click_delay": ([float, int], 0.1),
+        "search_back_off_delay": ([float, int], 0.5),
+        "search_warning_threshold": (int, 3),
+        "search_cut_off_limit": (int, 20),
+        "search_showing_only": (bool, False),
+        "children_limit": (int, 100),
+        "run_interval": ([float, int], 0.5),
+        "run_timeout": ([float, int], 30),
+        "gtk4_offset": ([list[int], tuple[int]], [12, 12]),
+        "debug_dogtail": (bool, False),
+        "debug_file": (str, "/tmp/dogtail_debug.log"),
+        "debug_searching": (bool, False),
+        "debug_sleep": (bool, False),
+        "debug_search_paths": (bool, False),
+        "absolute_node_paths": (bool, False),
+        "ensure_sensitivity": (bool, False),
+        "fatal_errors": (bool, False),
+        "check_for_a11y": (bool, True),
+    },
+    "user_config": {
+        "user_value_x": (object, "user_value_x"),
+    },
+}
+
+
+class ConfigValidationError(Exception):
+    pass
+
+
+def cast_basic(value: str, expected_type):
+    """
+    Casts primitive types.
+    """
+
+    if isinstance(value, str) and expected_type is bool:
+        lower = value.lower()
+
+        if lower in YES_VALUES:
+            return True
+
+        if lower in NO_VALUES:
+            return False
+
+        raise ValueError(f"Invalid boolean: {value}")
+
+    return expected_type(value)
+
+
+def cast_sequence(value: str, expected_container):
+    """
+    Casts comma-separated values into list[...] or tuple[...].
+    """
+
+    origin = get_origin(expected_container)
+    (item_type,) = get_args(expected_container)
+
+    # Strip optional list/tuple brackets like [1,2,3] or (1,2,3).
+    cleaned = value.strip()
+    if (cleaned.startswith("[") and cleaned.endswith("]")) or \
+       (cleaned.startswith("(") and cleaned.endswith(")")):
+        cleaned = cleaned[1:-1].strip()
+
+    # Split by comma.
+    items = [x.strip() for x in cleaned.split(",") if x.strip()]
+
+    casted = [cast_value(x, item_type) for x in items]
+
+    if origin is list:
+        return casted
+
+    if origin is tuple:
+        return tuple(casted)
+
+    raise ValueError(f"Unsupported sequence type: {origin}")
+
+
+def cast_value(value, expected_type):
+    # --- Union-of-types support ---
+    if isinstance(expected_type, list):
+        errors = []
+        for t in expected_type:
+            try:
+                return cast_value(value, t)
+            except Exception as e:
+                errors.append(str(e))
+        raise ValueError(" | ".join(errors))
+
+    origin = get_origin(expected_type)
+    args = get_args(expected_type)
+
+    # --- Handle sequences ---
+    if origin in (list, tuple):
+        # If value is already the correct container type, just validate inner types
+        if isinstance(value, origin):
+            if args:
+                item_type = args[0]
+                for i, item in enumerate(value):
+                    if not isinstance(item, item_type):
+                        raise ValueError(f"Element '{i}' in '{value}' is not of type '{item_type}'.")
+            return value
+        # Otherwise parse string into sequence
+        return cast_sequence(value, expected_type)
+
+    # --- Handle simple types ---
+    # If value is already of correct type, return.
+    if isinstance(value, expected_type):
+        return value
+
+    # If the value is object.
+    if expected_type is object:
+        return value
+
+    # Otherwise, cast string to type
+    return cast_basic(value, expected_type)
+
+
+def load_and_validate_config(path: str, schema: dict):
+    config = configparser.ConfigParser()
+    config.read(path)
+
+    validated = {}
+
+    # We do not care about config sections in dogtail, just set the variables to a dict.
+
+    # Step 1: Process all sections found in the file, even if not in schema.
+    LOGGING.debug("Process all variables.")
+    for section in config.sections():
+
+        for key, raw_value in config[section].items():
+            # If schema defines type → validate
+            if section in schema and key in schema[section]:
+                expected_type, default_value = schema[section][key]
+
+                try:
+                    value = cast_value(raw_value, expected_type)
+                except Exception as e:
+                    raise ConfigValidationError(
+                        f"Type error in [{section}].{key}: {e}"
+                    )
+
+                validated[key] = value
+                LOGGING.debug(f"Set Validated key '{key}' to value '{value}'")
+
+            else:
+                # Unknown key → keep raw value as string
+                validated[key] = raw_value
+                LOGGING.debug(f"Set Validated key '{key}' to raw value '{raw_value}'")
+
+    LOGGING.debug("Process default variables.")
+    # Step 2: Ensure missing schema sections & keys get default values.
+    for section, fields in schema.items():
+        for key, (expected_type, default_value) in fields.items():
+            if key not in validated:
+                validated[key] = default_value
+                LOGGING.debug(f"Set Default key '{key}' to value '{default_value}'")
+
+    return validated
+
+
+class _Config:
+    """
+    Config class to keep backwards compatibility and to have getters and setters.
+    """
+
+    validated_config = load_and_validate_config("dogtail_config.ini", CONFIG_SCHEMA)
+    LOGGING.debug(f"Validated config: '{validated_config}'")
+
+    # Create a deep copy instead of shallow copy to keep values for reset method.
+    _default_values_storage = copy.deepcopy(validated_config)
+
+    # Handle dogtail debug logging.
+    if validated_config["debug_dogtail"]:
+        LOGGING.info("Debugging dogtail to console.")
+        logging_class.debug_to_console()
+
+
+    def reset_configuration(self):
+        """
+        Reset configuration to default values.
+        """
+
+        LOGGING.debug(logging_class.get_func_params_and_values())
+
+        self.validated_config.update(self._default_values_storage)
+
+
+    def adjust_casing(self, string_to_fix):
+        """
+        Transforms a string to snake_case.
+
+        :param string_to_fix: String to transform to snake_case
+        :type string_to_fix: str
+
+        :return: Transformed string.
+        :rtype: str
+        """
+
+        LOGGING.debug(logging_class.get_func_params_and_values())
+
+        string_in_snake_case = ""
+        for character in string_to_fix:
+            if character.isalpha and character.isupper():
+                string_in_snake_case += "_" + character.lower()
+            else:
+                string_in_snake_case += character
+
+        return string_in_snake_case
+
+
+    def __setattr__(self, option_id, value_to_set):
+        LOGGING.debug(logging_class.get_func_params_and_values())
+
+        # Set a variable to use for the setter logic.
+        set_option_id = option_id
+
+        # Attempt to have some backwards compatibility and support camelCase.
+        if any(char.isupper() for char in set_option_id):
+            set_option_id = self.adjust_casing(set_option_id)
+            LOGGING.debug(f"Config variable was transformed to '{set_option_id}'.")
+
+        # Set custom user value to use in dogtail run.
+        # Current logic will fail on any attempt not set in config.ini.
+        # Should we allow setting values during a dogtail execution?
+        # if "custom_" in set_option_id:
+        #     LOGGING.info(f"Setting a custom user value '{set_option_id}'.")
+        #     self.options[set_option_id] = value_to_set
+
+        # In other cases check that the value exists.
+        if set_option_id not in self.validated_config:
+            raise AttributeError(f"Attempt to use invalid option '{set_option_id}'.")
+            # LOGGING.info(f"Attempt to use invalid option '{set_option_id}'.")
+            # return
+
+        # Set the value if the value is not already present.
+        if self.validated_config[set_option_id] != value_to_set:
+
+            validated_expected_type = None
+
+            # First attempt to get defaults from the schema.
+            for section in CONFIG_SCHEMA.keys():
+                if set_option_id in CONFIG_SCHEMA[section]:
+                    validated_expected_type, default_value = CONFIG_SCHEMA[section][set_option_id]
+
+            # If unsuccessful mark the expected type as anything.
+            if not validated_expected_type:
+                LOGGING.debug("Setting expected type to object.")
+                validated_expected_type = object
+
+            try:
+                # Set the value.
+                self.validated_config[set_option_id] = cast_value(value_to_set, validated_expected_type)
+            except Exception:
+                # Log the message but do not end, use the default.
+                LOGGING.info(" ".join((
+                    f"Attempt to set value of type '{type(value_to_set)}'",
+                    f"to key with accepted types '{validated_expected_type}'",
+                )))
+                # Setting the value.
+                LOGGING.info(f"Fallback of config option '{set_option_id}' to '{default_value}'.")
+                self.validated_config[set_option_id] = default_value
+
+            if set_option_id == "debug_dogtail" and self.validated_config[set_option_id]:
+                LOGGING.info("Debugging dogtail to console.")
+                logging_class.debug_to_console()
+
+            if set_option_id == "debug_dogtail" and not self.validated_config[set_option_id]:
+                LOGGING.info("Disabling debugging dogtail to console.")
+                logging_class.disable_debug_to_console()
+
+
+    def __getattr__(self, option_id):
+        # Set a variable to use for the getter logic.
+        get_option_id = option_id
+
+        # Attempt to have some backwards compatibility and support camelCase.
+        if any(char.isupper() for char in get_option_id):
+            get_option_id = self.adjust_casing(get_option_id)
+            LOGGING.debug(f"Config variable was transformed to '{get_option_id}'.")
+            LOGGING.debug(f"Its value is '{self.validated_config[get_option_id]}'.")
+
+        try:
+            return self.validated_config[get_option_id]
+        except KeyError as error:
+            raise AttributeError(f"Attempt to use invalid option '{get_option_id}'.") from error
+            # LOGGING.info(f"Attempt to use invalid option '{get_option_id}'.")
+
+
+config = _Config()

{dogtail-2.0.dev10 → dogtail-2.0.dev11}/dogtail/scripts/dogtail_create_config.py

@@ -7,24 +7,18 @@ Create configuration in your current directory.
 
 import os
 import sys
-from dogtail.config import config
+from dogtail.config import CONFIG_SCHEMA as schema
 
 def main():
     directory = os.path.realpath(os.getcwd())
 
-
-    # Print the retrieved values
-
     configuration = ""
-    configuration += "[config]\n"
-
-    for key, value in config.options.items():
-        configuration += f"{key} = {value.value}\n"
 
-    configuration += "[user_config]\n"
-    configuration += "user_value_x = user_value_x\n"
-    configuration += "user_value_y = user_value_y\n"
-    configuration += "user_value_z = user_value_z\n"
+    for section in schema.keys():
+        configuration += f"[{section}]\n"
+        for key, scheme_value in schema[section].items():
+            _, raw_value = scheme_value
+            configuration += f"{key} = {raw_value}\n"
 
     try:
         if os.path.isfile("dogtail_config.ini"):

dogtail-2.0.dev11/dogtail/scripts/dogtail_get_config.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""
+Print default configuration.
+"""
+
+from dogtail.config import config, CONFIG_SCHEMA
+
+def main():
+    # Print the retrieved values
+
+    print("Configuration.")
+
+    expected_types = {}
+    header_options = "Config Options"
+    header_value = "Value"
+    header_type = "Acceptable Types"
+
+    max_string_options_length = len(header_options)
+    max_string_value_length = len(header_value)
+
+    for section, fields in CONFIG_SCHEMA.items():
+        for key, (expected_type, default_value) in fields.items():
+            expected_types[key] = (expected_type, default_value)
+
+    for key, value in config.validated_config.items():
+        max_string_options_length = max(max_string_options_length, len(key))
+        max_string_value_length = max(max_string_value_length, len(str(value)))
+
+    print(f"{header_options:<{max_string_options_length+2}} {header_value:<{max_string_value_length+1}} {header_type}")
+
+    for key, value in config.validated_config.items():
+        expected_type = "object"
+        if key in expected_types.keys():
+            expected_type = str(expected_types[key][0])
+        print(f"{key:<{max_string_options_length + 1}}: {str(value):<{max_string_value_length + 1}} '{expected_type}'")
+
+if __name__ == "__main__":
+    main()

{dogtail-2.0.dev10 → dogtail-2.0.dev11}/dogtail.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dogtail
-Version: 2.0.dev10
+Version: 2.0.dev11
 Summary: GUI test tool and automation framework that uses Accessibility (AT-SPI) technologies to communicate with desktop applications.
 Author-email: Zack Cerza <zcerza@redhat.com>, Ed Rousseau <rousseau@redhat.com>, David Malcolm <dmalcolm@redhat.com>, Vitezslav Humpa <vhumpa@redhat.com>, Michal Odehnal <modehnal@redhat.com>
 License-Expression: GPL-2.0

{dogtail-2.0.dev10 → dogtail-2.0.dev11}/pyproject.toml

@@ -4,6 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dogtail"
+#version = "v2.0.dev0"
 dynamic = ["version"]
 description = "GUI test tool and automation framework that uses Accessibility (AT-SPI) technologies to communicate with desktop applications."
 license = "GPL-2.0"

dogtail-2.0.dev10/dogtail/config.py

@@ -1,255 +0,0 @@
-#!/usr/bin/python3
-"""
-Experimental dogtail changes for 2.0 release.
-"""
-
-# pylint: disable=line-too-long
-# ruff: noqa: E501
-
-import configparser
-from configparser import NoSectionError
-
-import copy
-
-from dogtail.logging import logging_class
-LOGGING = logging_class.logger
-
-
-NO_VALUES = ["", "n", "no", "f", "false", "False", "0"]
-
-
-class Value:
-    """
-    Value class to keep value and its types.
-    """
-
-    def __init__(self, set_value, defined_types=list):
-        self.value = set_value
-        self.defined_types = defined_types
-
-    def __str__(self):
-        return f"Default Value: '{self.value}'. Defined Types: '{str(self.defined_types)}'"
-
-    def __repr__(self):
-        return self.__str__()
-
-
-class LoadDefaultConfiguration:
-    """
-    Configuration class for default values.
-    """
-
-    def __init__(self, config_parser):
-        # Access values from the configuration file.
-        self.cfg = config_parser
-
-        # Timing Delay section.
-        section = "config"
-        self.action_delay = float(self.cfg.get(section, "action_delay", fallback=1))
-        self.typing_delay = float(self.cfg.get(section, "typing_delay", fallback=0.1))
-        self.default_delay = float(self.cfg.get(section, "default_delay", fallback=0.5))
-        self.double_click_delay = float(self.cfg.get(section, "double_click_delay", fallback=0.1))
-        self.search_back_off_delay = float(self.cfg.get(section, "search_back_off_delay", fallback=0.5))
-
-        # Searching section.
-        self.search_warning_threshold = int(self.cfg.get(section, "search_warning_threshold", fallback=3))
-        self.search_cut_off_limit = int(self.cfg.get(section, "search_cut_off_limit", fallback=20))
-        self.search_showing_only = self.cfg.get(section, "search_showing_only", fallback="False") not in NO_VALUES
-
-        # Children Limit section.
-        self.children_limit = int(self.cfg.get(section, "children_limit", fallback=100))
-
-        # Util Scripts section.
-        self.run_interval = float(self.cfg.get(section, "run_interval", fallback=0.5))
-        self.run_timeout = int(self.cfg.get(section, "run_timeout", fallback=30))
-
-        # GTK4Offset section.
-        self.gtk4_offset = list(self.cfg.get(section, "gtk4_offset", fallback=(12, 12)))
-
-        # Debug section.
-        self.debug_dogtail = self.cfg.get(section, "debug_dogtail", fallback="False") not in NO_VALUES
-        self.debug_file = self.cfg.get(section, "debug_file", fallback="/tmp/dogtail_debug.log")
-
-        # Other debug section.
-        self.debug_searching = self.cfg.get(section, "debug_searching", fallback="False") not in NO_VALUES
-        self.debug_sleep = self.cfg.get(section, "debug_sleep", fallback="False") not in NO_VALUES
-        self.debug_search_paths = self.cfg.get(section, "debug_search_paths", fallback="False") not in NO_VALUES
-
-        # Debug section. ?
-        #self.log_debug_to_std_out = self.cfg.get(section, "log_debug_to_std_out", fallback="True") not in NO_VALUES
-        self.absolute_node_paths = self.cfg.get(section, "absolute_node_paths", fallback="False") not in NO_VALUES
-        self.ensure_sensitivity = self.cfg.get(section, "ensure_sensitivity", fallback="False") not in NO_VALUES
-        self.fatal_errors = self.cfg.get(section, "fatal_errors", fallback="False") not in NO_VALUES
-        self.check_for_a11y = self.cfg.get(section, "check_for_a11y", fallback="True") not in NO_VALUES
-
-        if self.debug_dogtail:
-            LOGGING.info("Debugging dogtail to console.")
-            logging_class.debug_to_console()
-
-
-class _Config:
-    """
-    Config class to keep backwards compatibility and to have getters and setters.
-    """
-
-    # Create a ConfigParser object.
-    config_parser = configparser.ConfigParser()
-
-    # Read the configuration file.
-    successful_file_parsed = config_parser.read("dogtail_config.ini")
-    _default = LoadDefaultConfiguration(config_parser)
-
-    # Return a dictionary with the retrieved values.
-    # Define allowed type so that user cannot by mistake set different type than allowed.
-    options = {
-        "action_delay": Value(_default.action_delay, [float, int]),
-        "typing_delay": Value(_default.typing_delay, [float, int]),
-        "default_delay": Value(_default.default_delay, [float, int]),
-        "double_click_delay": Value(_default.double_click_delay, [float, int]),
-        "search_back_off_delay": Value(_default.search_back_off_delay, [float, int]),
-
-        "search_warning_threshold": Value(_default.search_warning_threshold, [int]),
-        "search_cut_off_limit": Value(_default.search_cut_off_limit, [int]),
-        "search_showing_only": Value(_default.search_showing_only, [bool]),
-
-        "children_limit": Value(_default.children_limit, [int]),
-
-        "run_interval": Value(_default.run_interval, [float, int]),
-        "run_timeout": Value(_default.run_timeout, [float, int]),
-
-        "gtk4_offset": Value(_default.gtk4_offset, [list, tuple]),
-
-        "debug_dogtail": Value(_default.debug_dogtail, [bool]),
-        "debug_file": Value(_default.debug_file, [str]),
-
-        "debug_searching": Value(_default.debug_searching, [bool]),
-        "debug_sleep": Value(_default.debug_sleep, [bool]),
-        "debug_search_paths": Value(_default.debug_search_paths, [bool]),
-
-        #"log_debug_to_std_out": Value(_default.log_debug_to_std_out, [bool]),
-        "absolute_node_paths": Value(_default.absolute_node_paths, [bool]),
-        "ensure_sensitivity": Value(_default.ensure_sensitivity, [bool]),
-        "fatal_errors": Value(_default.fatal_errors, [bool]),
-        "check_for_a11y": Value(_default.check_for_a11y, [bool]),
-    }
-
-    # Create a deep copy instead of shallow copy to keep values for reset method.
-    _default_values_storage = copy.deepcopy(options)
-
-    # User configuration.
-    section = "user_config"
-    try:
-        user_setting_dictionary = dict(_default.cfg.items(section))
-
-        # Set all user setup.
-        for key, value in user_setting_dictionary.items():
-            # Should we force 'custom_' prefix on users?
-            # As of now I opted to not do that, users can define any option they want.
-            options[key] = Value(value, [type(value)])
-
-    except NoSectionError:
-        # Do nothing, no user setting defined, which is ok.
-        pass
-
-    except Exception as error:
-        raise RuntimeError("Unexpected exception caught.") from error
-
-
-    def reset_configuration(self):
-        """
-        Reset configuration to default values.
-        """
-
-        LOGGING.debug(logging_class.get_func_params_and_values())
-
-        self.options.update(self._default_values_storage)
-
-
-    def adjust_casing(self, string_to_fix):
-        """
-        Transforms a string to snake_case.
-
-        :param string_to_fix: String to transform to snake_case
-        :type string_to_fix: str
-
-        :return: Transformed string.
-        :rtype: str
-        """
-
-        LOGGING.debug(logging_class.get_func_params_and_values())
-
-        string_in_snake_case = ""
-        for character in string_to_fix:
-            if character.isalpha and character.isupper():
-                string_in_snake_case += "_" + character.lower()
-            else:
-                string_in_snake_case += character
-
-        return string_in_snake_case
-
-
-    def __setattr__(self, option_id, value_to_set):
-        LOGGING.debug(logging_class.get_func_params_and_values())
-
-        # Set a variable to use for the setter logic.
-        set_option_id = option_id
-
-        # Attempt to have some backwards compatibility and support camelCase.
-        if any(char.isupper() for char in set_option_id):
-            set_option_id = self.adjust_casing(set_option_id)
-            LOGGING.debug(f"Value was transformed to '{set_option_id}'.")
-
-        # Set custom user value to use in dogtail run.
-        # Current logic will fail on any attempt not set in config.ini.
-        # Should we allow setting values during a dogtail execution?
-        # if "custom_" in set_option_id:
-        #     LOGGING.info(f"Setting a custom user value '{set_option_id}'.")
-        #     self.options[set_option_id] = value_to_set
-
-        # In other cases check that the value exists.
-        if set_option_id not in self.options:
-            raise AttributeError(f"Attempt to use invalid option '{set_option_id}'.")
-            # LOGGING.info(f"Attempt to use invalid option '{set_option_id}'.")
-            # return
-
-        # Set the value if the value is not already present.
-        if self.options[set_option_id].value != value_to_set:
-            # Defined types variable.
-            _defined_types = self.options[set_option_id].defined_types
-
-            # Type checking.
-            if type(value_to_set) not in _defined_types:
-                raise ValueError(" ".join((
-                    f"Attempt to set value of type '{type(value_to_set)}'",
-                    f"to key with accepted types '{_defined_types}'",
-                )))
-
-            # Type was checked, keep the defined types.
-            self.options[set_option_id] = Value(value_to_set, _defined_types)
-
-            if set_option_id == "debug_dogtail" and self.options[set_option_id].value:
-                LOGGING.info("Debugging dogtail to console.")
-                logging_class.debug_to_console()
-
-            if set_option_id == "debug_dogtail" and not self.options[set_option_id].value:
-                LOGGING.info("Disabling debugging dogtail to console.")
-                logging_class.disable_debug_to_console()
-
-
-    def __getattr__(self, option_id):
-        # Set a variable to use for the getter logic.
-        get_option_id = option_id
-
-        # Attempt to have some backwards compatibility and support camelCase.
-        if any(char.isupper() for char in get_option_id):
-            get_option_id = self.adjust_casing(get_option_id)
-            LOGGING.debug(f"Value was transformed to '{get_option_id}'.")
-
-        try:
-            return self.options[get_option_id].value
-        except KeyError as error:
-            raise AttributeError(f"Attempt to use invalid option '{get_option_id}'.") from error
-            # LOGGING.info(f"Attempt to use invalid option '{get_option_id}'.")
-
-
-config = _Config()

dogtail-2.0.dev10/dogtail/scripts/dogtail_get_config.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-"""
-Print default configuration.
-"""
-
-from dogtail.config import config
-
-def main():
-    # Print the retrieved values
-
-    print("Configuration.")
-    for key, value in config.options.items():
-        print(f"{key:25}: {value.value} {value.defined_types}")
-
-if __name__ == "__main__":
-    main()