gridparse 1.5.0__tar.gz → 1.5.2__tar.gz

{gridparse-1.5.0/gridparse.egg-info → gridparse-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gridparse
-Version: 1.5.0
+Version: 1.5.2
 Summary: Grid search directly from argparse
 Home-page: https://github.com/gchochla/gridparse
 Author: Georgios Chochlakis

{gridparse-1.5.0 → gridparse-1.5.2}/gridparse/grid_argument_parser.py

@@ -8,6 +8,328 @@ from omegaconf import OmegaConf
 from gridparse.utils import list_as_dashed_str, strbool
 
 
+class AuxArgumentParser(argparse.ArgumentParser):
+    """Overwritten only to collect the argument names that
+    are specified in the command line."""
+
+    def parse_known_args(
+        self, args=None, namespace=None
+    ) -> Tuple[argparse.Namespace, List[str]]:
+        """Overwritten to collect the argument names that
+        are specified in the command line."""
+        if args is None:
+            # args default to the system args
+            args = argparse._sys.argv[1:]
+        else:
+            # make sure that args are mutable
+            args = list(args)
+
+        # default Namespace built from parser defaults
+        if namespace is None:
+            namespace = argparse.Namespace()
+
+        if not hasattr(namespace, "___specified_args___"):
+            setattr(namespace, "___specified_args___", set())
+
+        # add any action defaults that aren't present
+        for action in self._actions:
+            if action.dest is not argparse.SUPPRESS:
+                if not hasattr(namespace, action.dest):
+                    if action.default is not argparse.SUPPRESS:
+                        setattr(namespace, action.dest, action.default)
+
+        # add any parser defaults that aren't present
+        for dest in self._defaults:
+            if not hasattr(namespace, dest):
+                setattr(namespace, dest, self._defaults[dest])
+
+        # parse the arguments and exit if there are any errors
+        if self.exit_on_error:
+            try:
+                namespace, args = self._parse_known_args(args, namespace)
+            except argparse.ArgumentError:
+                err = argparse._sys.exc_info()[1]
+                self.error(str(err))
+        else:
+            namespace, args = self._parse_known_args(args, namespace)
+
+        if hasattr(namespace, argparse._UNRECOGNIZED_ARGS_ATTR):
+            args.extend(getattr(namespace, argparse._UNRECOGNIZED_ARGS_ATTR))
+            delattr(namespace, argparse._UNRECOGNIZED_ARGS_ATTR)
+
+        return namespace, args
+
+    def _parse_known_args(
+        self, arg_strings, namespace
+    ) -> Tuple[List[argparse.Namespace], List[str]]:
+        """Overwritten to collect the argument names that
+        are specified in the command line."""
+
+        # replace arg strings that are file references
+        if self.fromfile_prefix_chars is not None:
+            arg_strings = self._read_args_from_files(arg_strings)
+
+        # map all mutually exclusive arguments to the other arguments
+        # they can't occur with
+        action_conflicts = {}
+        for mutex_group in self._mutually_exclusive_groups:
+            group_actions = mutex_group._group_actions
+            for i, mutex_action in enumerate(mutex_group._group_actions):
+                conflicts = action_conflicts.setdefault(mutex_action, [])
+                conflicts.extend(group_actions[:i])
+                conflicts.extend(group_actions[i + 1 :])
+
+        # find all option indices, and determine the arg_string_pattern
+        # which has an 'O' if there is an option at an index,
+        # an 'A' if there is an argument, or a '-' if there is a '--'
+        option_string_indices = {}
+        arg_string_pattern_parts = []
+        arg_strings_iter = iter(arg_strings)
+        for i, arg_string in enumerate(arg_strings_iter):
+
+            # all args after -- are non-options
+            if arg_string == '--':
+                arg_string_pattern_parts.append('-')
+                for arg_string in arg_strings_iter:
+                    arg_string_pattern_parts.append('A')
+
+            # otherwise, add the arg to the arg strings
+            # and note the index if it was an option
+            else:
+                option_tuple = self._parse_optional(arg_string)
+                if option_tuple is None:
+                    pattern = 'A'
+                else:
+                    option_string_indices[i] = option_tuple
+                    pattern = 'O'
+                arg_string_pattern_parts.append(pattern)
+
+        # join the pieces together to form the pattern
+        arg_strings_pattern = ''.join(arg_string_pattern_parts)
+
+        # converts arg strings to the appropriate and then takes the action
+        seen_actions = set()
+        seen_non_default_actions = set()
+
+        def take_action(action, argument_strings, option_string=None):
+            seen_actions.add(action)
+            argument_values = self._get_values(action, argument_strings)
+
+            # error if this argument is not allowed with other previously
+            # seen arguments, assuming that actions that use the default
+            # value don't really count as "present"
+            if argument_values is not action.default:
+                seen_non_default_actions.add(action)
+                for conflict_action in action_conflicts.get(action, []):
+                    if conflict_action in seen_non_default_actions:
+                        msg = argparse._('not allowed with argument %s')
+                        action_name = argparse._get_action_name(conflict_action)
+                        raise argparse.ArgumentError(action, msg % action_name)
+
+            # take the action if we didn't receive a SUPPRESS value
+            # (e.g. from a default)
+            if argument_values is not argparse.SUPPRESS:
+                action(self, namespace, argument_values, option_string)
+                namespace.___specified_args___.add(action.dest)
+
+        # function to convert arg_strings into an optional action
+        def consume_optional(start_index):
+
+            # get the optional identified at this index
+            option_tuple = option_string_indices[start_index]
+            action, option_string, explicit_arg = option_tuple
+
+            # identify additional optionals in the same arg string
+            # (e.g. -xyz is the same as -x -y -z if no args are required)
+            match_argument = self._match_argument
+            action_tuples = []
+            while True:
+
+                # if we found no optional action, skip it
+                if action is None:
+                    extras.append(arg_strings[start_index])
+                    return start_index + 1
+
+                # if there is an explicit argument, try to match the
+                # optional's string arguments to only this
+                if explicit_arg is not None:
+                    arg_count = match_argument(action, 'A')
+
+                    # if the action is a single-dash option and takes no
+                    # arguments, try to parse more single-dash options out
+                    # of the tail of the option string
+                    chars = self.prefix_chars
+                    if (
+                        arg_count == 0
+                        and option_string[1] not in chars
+                        and explicit_arg != ''
+                    ):
+                        action_tuples.append((action, [], option_string))
+                        char = option_string[0]
+                        option_string = char + explicit_arg[0]
+                        new_explicit_arg = explicit_arg[1:] or None
+                        optionals_map = self._option_string_actions
+                        if option_string in optionals_map:
+                            action = optionals_map[option_string]
+                            explicit_arg = new_explicit_arg
+                        else:
+                            msg = argparse._('ignored explicit argument %r')
+                            raise argparse.ArgumentError(
+                                action, msg % explicit_arg
+                            )
+
+                    # if the action expect exactly one argument, we've
+                    # successfully matched the option; exit the loop
+                    elif arg_count == 1:
+                        stop = start_index + 1
+                        args = [explicit_arg]
+                        action_tuples.append((action, args, option_string))
+                        break
+
+                    # error if a double-dash option did not use the
+                    # explicit argument
+                    else:
+                        msg = argparse._('ignored explicit argument %r')
+                        raise argparse.ArgumentError(action, msg % explicit_arg)
+
+                # if there is no explicit argument, try to match the
+                # optional's string arguments with the following strings
+                # if successful, exit the loop
+                else:
+                    start = start_index + 1
+                    selected_patterns = arg_strings_pattern[start:]
+                    arg_count = match_argument(action, selected_patterns)
+                    stop = start + arg_count
+                    args = arg_strings[start:stop]
+                    action_tuples.append((action, args, option_string))
+                    break
+
+            # add the Optional to the list and return the index at which
+            # the Optional's string args stopped
+            assert action_tuples
+            for action, args, option_string in action_tuples:
+                take_action(action, args, option_string)
+            return stop
+
+        # the list of Positionals left to be parsed; this is modified
+        # by consume_positionals()
+        positionals = self._get_positional_actions()
+
+        # function to convert arg_strings into positional actions
+        def consume_positionals(start_index):
+            # match as many Positionals as possible
+            match_partial = self._match_arguments_partial
+            selected_pattern = arg_strings_pattern[start_index:]
+            arg_counts = match_partial(positionals, selected_pattern)
+
+            # slice off the appropriate arg strings for each Positional
+            # and add the Positional and its args to the list
+            for action, arg_count in zip(positionals, arg_counts):
+                args = arg_strings[start_index : start_index + arg_count]
+                start_index += arg_count
+                take_action(action, args)
+
+            # slice off the Positionals that we just parsed and return the
+            # index at which the Positionals' string args stopped
+            positionals[:] = positionals[len(arg_counts) :]
+            return start_index
+
+        # consume Positionals and Optionals alternately, until we have
+        # passed the last option string
+        extras = []
+        start_index = 0
+        if option_string_indices:
+            max_option_string_index = max(option_string_indices)
+        else:
+            max_option_string_index = -1
+        while start_index <= max_option_string_index:
+
+            # consume any Positionals preceding the next option
+            next_option_string_index = min(
+                [
+                    index
+                    for index in option_string_indices
+                    if index >= start_index
+                ]
+            )
+            if start_index != next_option_string_index:
+                positionals_end_index = consume_positionals(start_index)
+
+                # only try to parse the next optional if we didn't consume
+                # the option string during the positionals parsing
+                if positionals_end_index > start_index:
+                    start_index = positionals_end_index
+                    continue
+                else:
+                    start_index = positionals_end_index
+
+            # if we consumed all the positionals we could and we're not
+            # at the index of an option string, there were extra arguments
+            if start_index not in option_string_indices:
+                strings = arg_strings[start_index:next_option_string_index]
+                extras.extend(strings)
+                start_index = next_option_string_index
+
+            # consume the next optional and any arguments for it
+            start_index = consume_optional(start_index)
+
+        # consume any positionals following the last Optional
+        stop_index = consume_positionals(start_index)
+
+        # if we didn't consume all the argument strings, there were extras
+        extras.extend(arg_strings[stop_index:])
+
+        # make sure all required actions were present and also convert
+        # action defaults which were not given as arguments
+        required_actions = []
+        for action in self._actions:
+            if action not in seen_actions:
+                if action.required:
+                    required_actions.append(argparse._get_action_name(action))
+                else:
+                    # Convert action default now instead of doing it before
+                    # parsing arguments to avoid calling convert functions
+                    # twice (which may fail) if the argument was given, but
+                    # only if it was defined already in the namespace
+                    if (
+                        action.default is not None
+                        and isinstance(action.default, str)
+                        and hasattr(namespace, action.dest)
+                        and action.default is getattr(namespace, action.dest)
+                    ):
+                        setattr(
+                            namespace,
+                            action.dest,
+                            self._get_value(action, action.default),
+                        )
+
+        if required_actions:
+            self.error(
+                argparse._('the following arguments are required: %s')
+                % ', '.join(required_actions)
+            )
+
+        # make sure all required groups had one option present
+        for group in self._mutually_exclusive_groups:
+            if group.required:
+                for action in group._group_actions:
+                    if action in seen_non_default_actions:
+                        break
+
+                # if no actions were used, report the error
+                else:
+                    names = [
+                        argparse._get_action_name(action)
+                        for action in group._group_actions
+                        if action.help is not argparse.SUPPRESS
+                    ]
+                    msg = argparse._('one of the arguments %s is required')
+                    self.error(msg % ' '.join(names))
+
+        # return the updated namespace, the extra arguments, and the epxlicitly specified args
+        return namespace, extras
+
+
 # overwritten to fix issue in __call__
 class _GridSubparsersAction(argparse._SubParsersAction):
     def __call__(
@@ -57,7 +379,13 @@ class _GridSubparsersAction(argparse._SubParsersAction):
         subnamespaces, arg_strings = parser.parse_known_args(arg_strings, None)
         for subnamespace in subnamespaces:
             new_namespace = deepcopy(namespace)
+            new_namespace.___specified_args___.update(
+                subnamespace.___specified_args___
+            )
+
             for key, value in vars(subnamespace).items():
+                if key == "___specified_args___":
+                    continue
                 setattr(new_namespace, key, value)
             namespaces.append(new_namespace)
 
@@ -81,7 +409,7 @@ class _GridActionsContainer(argparse._ActionsContainer):
         self.register("action", "parsers", _GridSubparsersAction)
 
 
-class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
+class GridArgumentParser(_GridActionsContainer, AuxArgumentParser):
     """ArgumentParser that supports grid search.
 
     It transforms the following arguments in the corresponding way:
@@ -163,7 +491,7 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
 
     def __init__(self, retain_config_filename: bool = False, *args, **kwargs):
         """Initializes the GridArgumentParser.
-        
+
         Args:
             retain_config_filename: whether to keep the `gridparse-config` argument
                 in the namespace or not.
@@ -180,9 +508,9 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
             "Values will be used if not provided in the command line.",
         )
 
-
     def parse_args(self, *args, **kwargs):
         vals = super().parse_args(*args, **kwargs)
+
         # hacky way to return namespaces in subparser
         if "___namespaces___" in vals[0]:
             vals = [ns for subps_ns in vals for ns in subps_ns.___namespaces___]
@@ -220,21 +548,25 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
             cfg = {}
             if ns.gridparse_config is not None:
                 # reverse for priority to originally first configs
-                for potential_fn in reversed(getattr(ns, "gridparse_config", [])):
+                for potential_fn in reversed(
+                    getattr(ns, "gridparse_config", [])
+                ):
                     if os.path.isfile(potential_fn):
                         cfg = OmegaConf.merge(cfg, OmegaConf.load(potential_fn))
 
                 for arg in cfg:
                     if not hasattr(ns, arg):
                         continue
-                    if getattr(ns, arg) is None:
-                        setattr(ns, arg, getattr(cfg, arg))
+                    if arg not in ns.___specified_args___:
+                        setattr(ns, arg, cfg.get(arg))
 
             if not self._retain_config_filename:
                 delattr(ns, "gridparse_config")
 
+            delattr(ns, "___specified_args___")
+
         return vals
-    
+
     def _check_value(self, action, value):
         """Overwrites `_check_value` to support grid search with `None`s."""
         # converted value must be one of the choices (if specified)
@@ -243,7 +575,7 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
         ):  # allows value to be None without error
             args = {
                 "value": value,
-                "choices": ", ".join(map(repr, action.choices))
+                "choices": ", ".join(map(repr, action.choices)),
             }
             msg = argparse._(
                 "invalid choice: %(value)r (choose from %(choices)s)"
@@ -263,12 +595,12 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
             default == arg_string or arg_string is None
         ):
             return default
-    
+
         # if arg_string is "args.X" value,
         # then set up value so that X is grabbed from the same namespace later
         if arg_string.startswith("args."):
             return arg_string
-        
+
         # if arg_string is "_None_", then return None
         if (
             arg_string == "_None_"
@@ -304,16 +636,18 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
     @staticmethod
     def _add_split_in_arg(arg: str, split: str) -> str:
         """Adds the `split` to the name of the argument `arg`."""
-        
+
         if "_" in arg:
-        # if the user uses "_" as a delimiter, we use that
+            # if the user uses "_" as a delimiter, we use that
             delim = "_"
         else:
-        # otherwise, we use "-" (no necessary to check for it, e.g., could be CamelCase)
+            # otherwise, we use "-" (no necessary to check for it, e.g., could be CamelCase)
             delim = "-"
         return split + delim + arg
 
-    def add_argument(self, *args, **kwargs) -> Union[argparse.Action, List[argparse.Action]]:
+    def add_argument(
+        self, *args, **kwargs
+    ) -> Union[argparse.Action, List[argparse.Action]]:
         """Augments `add_argument` to support grid search.
         For parameters that are searchable, provide specification
         for a single value, and set the new argument `searchable`
@@ -346,10 +680,14 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
                     while cp_args[0][i] in self.prefix_chars:
                         i += 1
 
-                    cp_args[0] = cp_args[0][:i] + self._add_split_in_arg(cp_args[0][i:], split)
+                    cp_args[0] = cp_args[0][:i] + self._add_split_in_arg(
+                        cp_args[0][i:], split
+                    )
 
                 else:
-                    cp_kwargs["dest"] = self._add_split_in_arg(cp_kwargs["dest"], split)
+                    cp_kwargs["dest"] = self._add_split_in_arg(
+                        cp_kwargs["dest"], split
+                    )
 
                 actions.append(self.add_argument(*cp_args, **cp_kwargs))
 
@@ -388,7 +726,7 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
             self.subspaces = {}
             self.cnt = 0
             self.parent = parent
-        
+
         def add_arg(self, arg: str):
             if arg == "{":
                 new_subspace = GridArgumentParser.Subspace(self)
@@ -401,7 +739,7 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
                 self.args[self.cnt] = arg
                 self.cnt += 1
                 return self
-        
+
         def parse_paths(self) -> List[List[str]]:
 
             if not self.subspaces:
@@ -419,9 +757,9 @@ class GridArgumentParser(_GridActionsContainer, argparse.ArgumentParser):
                     this_subspace_args.append(self.args[i])
                     for path in cumulative_args:
                         path.append(self.args[i])
-            
+
             return cumulative_args
-    
+
         def __repr__(self) -> str:
             repr = "Subspace("
             for i in range(self.cnt):

{gridparse-1.5.0 → gridparse-1.5.2/gridparse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: gridparse
-Version: 1.5.0
+Version: 1.5.2
 Summary: Grid search directly from argparse
 Home-page: https://github.com/gchochla/gridparse
 Author: Georgios Chochlakis

{gridparse-1.5.0 → gridparse-1.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gridparse"
-version = "1.5.0"
+version = "1.5.2"
 description = "Grid search directly from argparse"
 readme = "README.md"
 requires-python = ">=3.7"
@@ -31,7 +31,6 @@ classifiers = [
   "Programming Language :: Python :: 3 :: Only",
 ]
 
-
 dependencies = [
   "omegaconf",
 ]

{gridparse-1.5.0 → gridparse-1.5.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="gridparse",
-    version="1.5.0",
+    version="1.5.2",
     description="Grid search directly from argparse",
     author="Georgios Chochlakis",
     author_email="georgioschochlakis@gmail.com",