certora-cli-beta-mirror 7.28.0__py3-none-any.whl → 8.5.0__py3-none-any.whl

certora_cli/CertoraProver/certoraConfigIO.py

@@ -13,13 +13,12 @@
 #     You should have received a copy of the GNU General Public License
 #     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-import json5
 import logging
 from pathlib import Path
-from typing import Dict, Any
+from typing import Dict, Any, cast
 
 import CertoraProver.certoraContext as Ctx
-import CertoraProver.certoraContextAttributes as Attrs
+import CertoraProver.certoraApp as App
 from CertoraProver.certoraContextClass import CertoraContext
 from Shared import certoraUtils as Util
 
@@ -46,11 +45,12 @@ def current_conf_to_file(context: CertoraContext) -> Dict[str, Any]:
     4. Parsing the .conf file is simpler, as we can ignore the null case
     """
     def input_arg_with_value(k: Any, v: Any) -> Any:
-        all_conf_names = Attrs.get_attribute_class().all_conf_names()
+        all_conf_names = context.app.attr_class.all_conf_names()
         return v is not None and v is not False and k in all_conf_names
 
     context_to_save = {k: v for k, v in vars(context).items() if input_arg_with_value(k, v)}
-    all_conf_names = Attrs.get_attribute_class().all_conf_names()
+    context_to_save = cast(Dict[str, Any], Util.convert_str_ints(context_to_save))
+    all_conf_names = context.app.attr_class.all_conf_names()
     context_to_save = dict(sorted(context_to_save.items(), key=lambda x: all_conf_names.index(x[0])))
     context_to_save.pop('build_dir', None)  # build dir should not be saved, each run should define its own build_dir
     context_to_save.pop('mutation_test_id', None)  # mutation_test_id should be recreated for every run
@@ -75,11 +75,11 @@ def read_from_conf_file(context: CertoraContext) -> None:
 
     try:
         with conf_file_path.open() as conf_file:
-            conf_file_attr = json5.load(conf_file, allow_duplicate_keys=False)
+            context.conf_file_attr = Util.read_conf_file(conf_file)
             try:
-                check_conf_content(conf_file_attr, context)
+                check_conf_content(context)
             except Util.CertoraUserInputError as e:
-                raise Util.CertoraUserInputError(f"Error when reading {conf_file_path}: {str(e)}", e) from None
+                raise Util.CertoraUserInputError(f"Error when reading {conf_file_path}: {e}") from None
             context.conf_file = str(conf_file_path)
     except FileNotFoundError:
         raise Util.CertoraUserInputError(f"read_from_conf_file: {conf_file_path}: not found") from None
@@ -96,24 +96,34 @@ def handle_override_base_config(context: CertoraContext) -> None:
     """
 
     if context.override_base_config:
-        with Path(context.override_base_config).open() as conf_file:
-            try:
-                override_base_config_attrs = json5.load(conf_file, allow_duplicate_keys=False)
+        try:
+            with (Path(context.override_base_config).open() as conf_file):
+                override_base_config_attrs = Util.read_conf_file(conf_file)
+                context.attrs_set_in_main_conf = context.conf_file_attr.copy()
+                context.conf_file_attr = {**override_base_config_attrs, **context.conf_file_attr}
 
                 if 'override_base_config' in override_base_config_attrs:
                     raise Util.CertoraUserInputError("base config cannot include 'override_base_config'")
-            except Exception as e:
-                raise Util.CertoraUserInputError(f"Cannot load base config: {context.override_base_config}\n{e}")
-            for attr in override_base_config_attrs:
-                if hasattr(context, attr):
-                    value = getattr(context, attr, False)
-                    if not value:
-                        setattr(context, attr, override_base_config_attrs.get(attr))
-                else:
-                    raise Util.CertoraUserInputError(f"{attr} appears in the base conf file {context.override_base_config} but is not a known attribute.")
-
-
-def check_conf_content(conf_file_attr: Dict[str, Any], context: CertoraContext) -> None:
+        except Exception as e:
+            raise Util.CertoraUserInputError(f"Cannot load base config: {context.override_base_config}\n{e}")
+
+        for attr in override_base_config_attrs:
+            if hasattr(context, attr):
+                value = getattr(context, attr, False)
+                if not value:
+                    # if boolean attribute does not appear in main conf but is True in the base conf, set it to True
+                    if override_base_config_attrs[attr] is True and attr not in context.attrs_set_in_main_conf:
+                        setattr(context, attr, True)
+                        continue
+                    # if boolean attribute does appear in main conf and is False, do not override it
+                    elif attr in context.conf_file_attr and value is False:
+                        continue  # skip override if a boolean attribute was explicitly set to False in the conf file
+                    setattr(context, attr, override_base_config_attrs.get(attr))
+            else:
+                raise Util.CertoraUserInputError(f"{attr} appears in the base conf file {context.override_base_config} but is not a known attribute.")
+
+
+def check_conf_content(context: CertoraContext) -> None:
     """
     validating content read from the conf file
     Note: a command line definition trumps the definition in the file.
@@ -122,15 +132,15 @@ def check_conf_content(conf_file_attr: Dict[str, Any], context: CertoraContext)
     @param context: A namespace containing options from the command line, if any
     """
 
-    for option in conf_file_attr:
+    for option in context.conf_file_attr:
         if hasattr(context, option):
             val = getattr(context, option)
             if val is None or val is False:
-                setattr(context, option, conf_file_attr[option])
-            elif option != Attrs.EvmProverAttributes.FILES.get_conf_key() and val != conf_file_attr[option]:
+                setattr(context, option, context.conf_file_attr[option])
+            elif option != 'files' and val != context.conf_file_attr[option]:
                 cli_val = ' '.join(val) if isinstance(val, list) else str(val)
-                conf_val = ' '.join(conf_file_attr[option]) \
-                    if isinstance(conf_file_attr[option], list) else str(conf_file_attr[option])
+                conf_val = ' '.join(context.conf_file_attr[option]) \
+                    if isinstance(context.conf_file_attr[option], list) else str(context.conf_file_attr[option])
                 run_logger.warning(f"Note: attribute {option} value in CLI ({cli_val}) overrides value stored in conf"
                                    f" file ({conf_val})")
         else:
@@ -138,12 +148,10 @@ def check_conf_content(conf_file_attr: Dict[str, Any], context: CertoraContext)
 
     handle_override_base_config(context)
 
-    if Attrs.is_evm_app() and 'files' not in conf_file_attr and not context.project_sanity and not context.foundry:
+    if Ctx.is_evm_app_class(context) and not context.files and not context.project_sanity and not context.foundry:
         raise Util.CertoraUserInputError("Mandatory 'files' attribute is missing from the configuration")
+    context.files = context.conf_file_attr.get('files')
+    if context.app == App.SorobanApp and not context.files and not context.build_script:
+        raise Util.CertoraUserInputError("'files' or 'build script' must be set for Soroban runs")
 
-    if Attrs.is_rust_app():
-        has_build_script = getattr(context, 'build_script', False)
-        if not has_build_script and 'files' not in conf_file_attr:
-            raise Util.CertoraUserInputError("Mandatory 'build_script' or 'files' attribute is missing from the configuration")
-
-    context.files = conf_file_attr.get('files')
+    context.files = context.conf_file_attr.get('files')

certora_cli/CertoraProver/certoraContext.py

@@ -20,10 +20,12 @@ import os
 import re
 import sys
 import logging
+import fnmatch
+from wcmatch import glob
 
 
 from pathlib import Path
-from typing import Dict, List, Optional, Any, Union
+from typing import Dict, List, Optional, Any, Union, Type
 from rich.console import Console
 
 scripts_dir_path = Path(__file__).parent.resolve()  # containing directory
@@ -37,6 +39,8 @@ import CertoraProver.certoraContextAttributes as Attrs
 
 from Shared import certoraValidateFuncs as Vf
 from Shared import certoraAttrUtil as AttrUtil
+import CertoraProver.certoraApp as App
+
 
 context_logger = logging.getLogger("context")
 
@@ -53,6 +57,11 @@ def escape_string(string: str) -> str:
     else:
         return f"\"{string}\""
 
+def is_evm_app_class(context: CertoraContext) -> bool:
+    return issubclass(context.app, App.EvmAppClass)
+
+def is_rust_app_class(context: CertoraContext) -> bool:
+    return issubclass(context.app, App.RustAppClass)
 
 def get_attr_value(context: CertoraContext, attr: AttrUtil.AttributeDefinition) -> Any:
     conf_key = attr.get_conf_key()
@@ -60,18 +69,18 @@ def get_attr_value(context: CertoraContext, attr: AttrUtil.AttributeDefinition)
 
 
 def collect_args_with_jar_flags(context: CertoraContext) -> List[AttrUtil.AttributeDefinition]:
-    attribute_list = Attrs.get_attribute_class().attribute_list()
+    attribute_list = context.app.attr_class.attribute_list()
     return [attr for attr in attribute_list if get_attr_value(context, attr) and attr.jar_flag]
 
 
 def collect_args_build_cache_affecting(context: CertoraContext) -> List[AttrUtil.AttributeDefinition]:
-    attribute_list = Attrs.get_attribute_class().attribute_list()
+    attribute_list = context.app.attr_class.attribute_list()
     return [attr for attr in attribute_list if get_attr_value(context, attr) and
             attr.affects_build_cache_key]
 
 
 def collect_args_build_cache_disabling(context: CertoraContext) -> List[AttrUtil.AttributeDefinition]:
-    attribute_list = Attrs.get_attribute_class().attribute_list()
+    attribute_list = context.app.attr_class.attribute_list()
     return [attr for attr in attribute_list if get_attr_value(context, attr) and
             attr.disables_build_cache]
 
@@ -120,18 +129,25 @@ def get_local_run_cmd(context: CertoraContext) -> List[str]:
     """
     run_args = []
 
-    if hasattr(context, 'rust_executables') and hasattr(context, 'rust_project_directory'):
-        run_args.append(os.path.join(context.rust_project_directory, context.rust_executables))
-    elif context.is_tac or Attrs.is_rust_app():
+    if context.app == App.SuiApp:
+        # For local runs, we want path to be relative to cwd instead of zip root.
+        move_rel_path = os.path.relpath(Path(context.move_path), os.getcwd())
+        run_args.extend(['-movePath', move_rel_path])
+    elif is_rust_app_class(context):
+        # For local runs, we want path to be relative to cwd instead of zip root.
+        rust_rel_path = os.path.relpath(Path(context.files[0]), os.getcwd())
+        run_args.append(rust_rel_path)
+    elif context.is_tac:
         # For Rust app we assume the files holds the executable for the prover, currently we support a single file
         try:
             run_args.append(context.files[0])
         except Exception:
             raise RuntimeError("get_local_run_cmd: cannot find context.files[0]")
 
-    if Attrs.is_evm_app() and context.cache is not None:
+    if is_evm_app_class(context) and context.cache is not None:
         run_args.extend(['-cache', context.cache])
-
+    if context.app == App.ConcordApp:
+        run_args.extend(['-equivalenceCheck', 'true'])
     jar_args = collect_jar_args(context)
     run_args.extend(jar_args)
 
@@ -148,27 +164,37 @@ def get_local_run_cmd(context: CertoraContext) -> List[str]:
         java_cmd.extend(context.java_args.strip().split(' '))
 
     cmd = java_cmd + ["-jar", jar_path] + run_args
-    if context.test == str(Util.TestValue.LOCAL_JAR):
-        raise Util.TestResultsReady(' '.join(cmd))
     return cmd
 
 
 class ProverParser(AttrUtil.ContextAttributeParser):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
+    def __init__(self, app: Type[App.CertoraApp], *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
+        self.app = app
 
     def format_help(self) -> str:
         console = Console()
-        console.print("\n\nThe Certora Prover - A formal verification tool for smart contracts")
+        if self.app == App.ConcordApp:
+            console.print("\n\nConcord - Certora’s equivalence checker for smart contracts")
+        elif self.app == App.RangerApp:
+            console.print("\n\nRanger - Certora’s bounded model checker for smart contracts")
+        else:
+            console.print("\n\nThe Certora Prover - A formal verification tool for smart contracts")
         # Using sys.stdout.write() as print() would color some of the strings here
         sys.stdout.write(f"\n\nUsage: {sys.argv[0]} <Files> <Flags>\n\n")
-        if Attrs.is_evm_app():
+        if self.app == App.ConcordApp:
+            sys.stdout.write("Concord supports only Solidity (.sol/.yul) and configuration (.conf) files.\n"
+                             "Rust and Vyper contracts are not currently supported.\n\n")
+        if self.app == App.RangerApp:
+            sys.stdout.write("Ranger supports only Solidity (.sol) and configuration (.conf) files.\n"
+                             "Rust and Vyper contracts are not currently supported.\n\n")
+        elif isinstance(self.app, App.EvmAppClass):
             sys.stdout.write("Acceptable files for EVM projects are Solidity files (.sol suffix), "
                              "Vyper files (.vy suffix), or conf files (.conf suffix)\n\n")
-        elif Attrs.is_solana_app():
+        elif self.app == App.SolanaApp:
             sys.stdout.write("Acceptable files for Solana projects are RUST executables ('.so' suffix) or conf "
                              "files ('.conf' suffix')\n\n")
-        elif Attrs.is_soroban_app():
+        elif self.app == App.SorobanApp:
             sys.stdout.write("Acceptable files for Soroban projects are WASM executables ('.wasm' suffix) or conf "
                              "files ('.conf' suffix')\n\n")
         else:
@@ -187,24 +213,23 @@ class ProverParser(AttrUtil.ContextAttributeParser):
 
         return ''
 
-def __get_argparser() -> argparse.ArgumentParser:
+def __get_argparser(app: Type[App.CertoraApp]) -> argparse.ArgumentParser:
     def formatter(prog: Any) -> argparse.HelpFormatter:
         return argparse.HelpFormatter(prog, max_help_position=100, width=200)
 
-    parser = ProverParser(prog="certora-cli arguments and options", allow_abbrev=False,
+    parser = ProverParser(app, prog="certora-cli arguments and options", allow_abbrev=False,
                           formatter_class=formatter,
                           epilog="  -*-*-*   You can find detailed documentation of the supported options in "
                                  f"{CLI_DOCUMENTATION_URL}   -*-*-*")
 
-    for arg in Attrs.get_attribute_class().attribute_list():
+    for arg in app.attr_class.attribute_list():
         flag = arg.get_flag()
         parser.add_argument(flag, help=arg.help_msg, **arg.argparse_args)
     return parser
 
-
-def get_args(args_list: Optional[List[str]] = None) -> CertoraContext:
+def get_args(args_list: List[str], app: Type[App.CertoraApp]) -> CertoraContext:
     """
-    Compiles an argparse.Namespace from the given list of command line arguments.
+    Compiles an CertoraContext object from the given list of command line arguments.
 
     Why do we handle --version before argparse?
     Because on some platforms, mainly CI tests, we cannot fetch the installed distribution package version of
@@ -212,15 +237,13 @@ def get_args(args_list: Optional[List[str]] = None) -> CertoraContext:
     We do it pre-argparse, because we do not care bout the input validity of anything else if we have a --version flag
     """
 
-    if not Attrs.ATTRIBUTES_CLASS:
-        Attrs.set_attribute_class(Attrs.EvmProverAttributes)  # for scripts that call get_args directly
     if args_list is None:
         args_list = sys.argv
 
     handle_version_flag(args_list)
 
     pre_arg_fetching_checks(args_list)
-    parser = __get_argparser()
+    parser = __get_argparser(app)
 
     # if there is a --help flag, we want to ignore all parsing errors, even those before it:
     if any(string in [arg.strip() for arg in args_list] for string in ['--help', '-h']):
@@ -235,6 +258,7 @@ def get_args(args_list: Optional[List[str]] = None) -> CertoraContext:
 
     args = parser.parse_args(args_list)
     context = CertoraContext(**vars(args))
+    context.app = app
     context.args_list = args_list
 
     __remove_parsing_whitespace(args_list)
@@ -243,17 +267,18 @@ def get_args(args_list: Optional[List[str]] = None) -> CertoraContext:
 
     if context.is_conf:
         read_from_conf_file(context)
-
+    context.process = None
     context.local = Util.is_local(context)
     context.is_tac = context.files and context.files[0].endswith('.tac')
     context.is_vyper = context.files and context.files[0].endswith('.vy')
 
-    if Attrs.is_evm_app():
+    if is_evm_app_class(context):
         Cv.check_mode_of_operation(context)  # Here boolean run characteristics are set
 
     validator = Cv.CertoraContextValidator(context)
+
     validator.validate()
-    if Attrs.is_evm_app() or Attrs.is_rust_app():
+    if is_evm_app_class(context) or is_rust_app_class(context):
         current_build_directory = Util.get_build_dir()
         if context.build_dir is not None and current_build_directory != context.build_dir:
             Util.reset_certora_internal_dir(context.build_dir)
@@ -265,14 +290,19 @@ def get_args(args_list: Optional[List[str]] = None) -> CertoraContext:
     if context.java_args is not None:
         context.java_args = ' '.join(context.java_args).replace('"', '').replace("'", '')
 
-    if Attrs.is_evm_app():
+    if is_evm_app_class(context) or context.app == App.ConcordApp:
         validator.check_args_post_argparse()
         setup_cache(context)  # Here context.cache, context.user_defined_cache are set
+        validator.handle_ranger_attrs()
+        validator.handle_concord_attrs()
+    if is_rust_app_class(context):
+        validator.check_rust_args_post_argparse()
 
     attrs_to_relative(context)
     # Setup defaults (defaults are not recorded in conf file)
     context.expected_file = context.expected_file or "expected.json"
     context.run_source = context.run_source or Vf.RunSources.COMMAND.name.upper()
+    context.java_version = Util.get_java_version()
 
     context_logger.debug("parsed args successfully.")
     context_logger.debug(f"args= {context}")
@@ -346,7 +376,7 @@ def format_input(context: CertoraContext) -> None:
     :param context: Namespace containing all command line arguments, generated by get_args()
     """
     flatten_arg_lists(context)
-    if Attrs.is_evm_app():
+    if is_evm_app_class(context):
         __dedup_link(context)
 
 
@@ -391,7 +421,7 @@ def setup_cache(context: CertoraContext) -> None:
     # we have a user defined cache key if the user provided a cache key
     context.user_defined_cache = context.cache is not None
     if not context.disable_auto_cache_key_gen and not os.environ.get("CERTORA_DISABLE_AUTO_CACHE") is not None:
-        if context.is_verify or context.is_assert or context.is_conf:
+        if context.is_verify or context.is_conf:
             # in local mode we don't want to create a cache key if not such is given
             if (context.cache is None) and (not context.local):
                 optimistic_loop = context.optimistic_loop
@@ -425,7 +455,7 @@ def write_output_conf_to_path(json_content: Dict[str, Any], path: Path) -> None:
         json.dump(json_content, out_file, indent=4, sort_keys=True)
 
 
-def handle_flags_in_args(args: List[str]) -> None:
+def handle_flags_in_args(args: List[str], app: Type[App.CertoraApp]) -> None:
     """
     For argparse flags are strings that start with a dash. Some arguments get flags as value.
     The problem is that argparse will not treat the string as a value but rather as a new flag. There are different ways
@@ -441,7 +471,7 @@ def handle_flags_in_args(args: List[str]) -> None:
     Will all be converted to " -d"
 
     """
-    all_flags = list(map(lambda member: member.get_flag(), Attrs.get_attribute_class().attribute_list()))
+    all_flags = list(map(lambda member: member.get_flag(), app.attr_class.attribute_list()))
 
     def surrounded(string: str, char: str) -> bool:
         if len(string) < 2:
@@ -492,14 +522,27 @@ def __rename_key(context: CertoraContext, old_key: str, new_key: str) -> None:
         context.delete_key(old_key)
 
 
-def run_typechecker(typechecker_name: str, with_typechecking: bool, args: List[str]) -> None:
+def should_run_local_speck_check(context: CertoraContext) -> bool:
+    output = context.compilation_steps_only or not (context.disable_local_typechecking or Util.is_ci_or_git_action())
+    if not output:
+        if context.disable_local_typechecking:
+            context_logger.warning(
+                "Local checks of CVL specification files disabled. It is recommended to enable the checks."
+            )
+        else:
+            context_logger.info("Local checks of CVL specification files skipped in CI and will run remotely.")
+    return output
+
+
+def run_typechecker(typechecker_name: str, with_typechecking: bool, args: List[str], print_errors: bool) -> None:
     """
     Runs a spec typechecker or syntax checker
-    @param typechecker_name - the name of the jar that we should run for running typechecking
-    @param with_typechecking - True if we want full typechecking including build (Solidity outputs) file,
+
+    @param typechecker_name: the name of the jar that we should run for running typechecking
+    @param with_typechecking: True if we want full typechecking including build (Solidity outputs) file,
                                 False if we run only the leaner syntax checking.
     @param args: A list of strings of additional arguments to the typechecker jar.
-
+    @param print_errors: Toggles printing the typechecker's errors to stderr.
     """
     # Find path to typechecker jar
     path_to_typechecker = Util.find_jar(typechecker_name)
@@ -512,31 +555,35 @@ def run_typechecker(typechecker_name: str, with_typechecking: bool, args: List[s
     if with_typechecking:
         cmd_str_list.append('-typeCheck')
 
+    context_logger.debug(f"typechecking cmd: {' '.join(cmd_str_list)}")
+
     exit_code = Util.run_jar_cmd(cmd_str_list, False,
-                                 custom_error_message="Failed to run Certora Prover locally. Please check the errors "
-                                                      "below for problems in the specifications (.spec files) or the "
-                                                      "prover_args defined in the .conf file.",
-                                 logger_topic="type_check")
+                                 custom_error_message="Failed to run Certora Prover typechecker locally.\n"
+                                                      "Please check the errors below for problems in the specifications"
+                                                      " (.spec files) or the prover_args defined in the .conf file.",
+                                 logger_topic="type_check",
+                                 print_err=print_errors)
     if exit_code != 0:
-        raise Util.CertoraUserInputError(
-            "CVL syntax or type check failed.\n Please fix the issue. "
-            "Using --disable_local_typechecking to skip this check is strongly discouraged, "
-            "as simple syntax errors will only be detected during the cloud run."
-            "with --disable_local_typechecking is not recommended is not recommended as "
-            "simple syntax failures will be visible only on the cloud run.")
+        raise Util.CertoraUserInputError("CVL syntax or type check failed, please fix the issue.")
 
 
-def run_local_spec_check(with_typechecking: bool, context: CertoraContext) -> None:
+def run_local_spec_check(with_typechecking: bool, context: CertoraContext, extra_args: List[str] = list(), print_errors: bool = True) -> None:
     """
-    Runs the local type checker in one of two modes: (1) syntax only,
-        and (2) including full typechecking after building the contracts
+    Runs the local type checker
+
+    @param with_typechecking: If `True` will perform a full typecheck pass which requires Solidity build information.
+                              Otherwise performs only a syntax check.
+
+    @param context: The `CertoraContext`.
+
+    @param extra_args: a list of additional arguments that should be sent to the typechecker.
+
+    @param print_errors: Toggles printing the typechecker's errors to stderr. Default: True
     """
 
-    if context.disable_local_typechecking or Util.is_ci_or_git_action():
-        return
     args = collect_jar_args(context)
-    if Util.is_java_installed():
-        run_typechecker("Typechecker.jar", with_typechecking, args)
+    if Util.is_java_installed(context.java_version):
+        run_typechecker("Typechecker.jar", with_typechecking, args + extra_args, print_errors)
     else:
         raise Util.CertoraUserInputError("Cannot run local checks because of missing a suitable java installation. "
                                          "To skip local checks run with the --disable_local_typechecking flag")
@@ -603,3 +650,30 @@ def attrs_to_relative(context: CertoraContext) -> None:
     packages_to_relative()
     prover_resource_file_to_relative()
     verify_to_relative()
+
+def get_map_attribute_value(context: CertoraContext, path: Path, attr_name: str) -> Optional[Union[str, bool]]:
+
+    value = getattr(context, attr_name, None)
+    if value:
+        return value
+
+    map_value = getattr(context, f"{attr_name}_map", None)
+    if not map_value:
+        return None  # No map value defined
+    for key, entry_value in map_value.items():
+        # Split key to handle contract:field syntax
+        key_parts = key.split(':')
+        pattern = key_parts[0]
+
+        if Path(pattern).suffix == "":  # This is a contract pattern
+            # Find contracts that match the pattern
+            for contract_name, contract_file_path in context.contract_to_file.items():
+                if fnmatch.fnmatch(contract_name, pattern):
+                    # Check if this contract's file matches our target path
+                    if str(path).endswith(contract_file_path):
+                        return entry_value
+        else:  # This is a file pattern
+            # Match the file pattern against the path
+            if glob.globmatch(str(path), pattern, flags=glob.GLOBSTAR):
+                return entry_value
+    raise RuntimeError(f"cannot match {attr_name} to {path} from {attr_name}_map")