diff --git a/jsonargparse/_actions.py b/jsonargparse/_actions.py index ea168144..9f0ae313 100644 --- a/jsonargparse/_actions.py +++ b/jsonargparse/_actions.py @@ -544,7 +544,7 @@ def _move_parser_actions(parser, args, kwargs): title = kwargs.pop("title", kwargs.pop("help", None)) description = kwargs.pop("description", subparser.description) if len(kwargs) > 0: - raise ValueError(f"ActionParser does not accept the following parameters: {set(kwargs.keys())}") + raise ValueError(f"ActionParser does not accept the following parameters: {set(kwargs)}") if not (len(args) == 1 and args[0].startswith("--")): raise ValueError(f"ActionParser only accepts a single optional key but got {args}") prefix = args[0][2:] @@ -558,7 +558,7 @@ def add_prefix(key): for key, action in filter_default_actions(subparser._option_string_actions).items(): option_string_actions[add_prefix(key)] = action - isect = set(option_string_actions.keys()).intersection(set(parser._option_string_actions.keys())) + isect = set(option_string_actions).intersection(set(parser._option_string_actions)) if len(isect) > 0: raise ValueError(f"ActionParser conflicting keys: {isect}") @@ -705,7 +705,7 @@ def get_subcommands( require_single = single_subcommand.get() # Get subcommand settings keys - subcommand_keys = [k for k in action.choices.keys() if isinstance(cfg.get(prefix + k), Namespace)] + subcommand_keys = [k for k in action.choices if isinstance(cfg.get(prefix + k), Namespace)] # Get subcommand subcommand = None @@ -735,7 +735,7 @@ def get_subcommands( # If subcommand is required and no subcommand is provided, # present the user with a friendly error message to remind them of # the available subcommands and to select one. - available_subcommands = list(action._name_parser_map.keys()) + available_subcommands = list(action._name_parser_map) if len(available_subcommands) <= 5: candidate_subcommands_str = "{" + ",".join(available_subcommands) + "}" else: diff --git a/jsonargparse/_cli.py b/jsonargparse/_cli.py index 622da1a2..73c93920 100644 --- a/jsonargparse/_cli.py +++ b/jsonargparse/_cli.py @@ -170,7 +170,7 @@ def _add_subcommands( def has_parameter(component, name) -> bool: - return name in inspect.signature(component).parameters.keys() + return name in inspect.signature(component).parameters def _add_component_to_parser( @@ -180,7 +180,7 @@ def _add_component_to_parser( fail_untyped: bool, config_help: str, ): - kwargs: dict = dict(as_positional=as_positional, fail_untyped=fail_untyped, sub_configs=True) + kwargs: dict = {"as_positional": as_positional, "fail_untyped": fail_untyped, "sub_configs": True} if inspect.isclass(component): class_methods = [ k for k, v in inspect.getmembers(component) if (callable(v) or isinstance(v, property)) and k[0] != "_" diff --git a/jsonargparse/_common.py b/jsonargparse/_common.py index 1dd4115f..789550e0 100644 --- a/jsonargparse/_common.py +++ b/jsonargparse/_common.py @@ -65,16 +65,16 @@ def __call__(self, class_type: Type[ClassType], *args, **kwargs) -> ClassType: applied_instantiation_links: ContextVar[Optional[set]] = ContextVar("applied_instantiation_links", default=None) -parser_context_vars = dict( - parent_parser=parent_parser, - parser_capture=parser_capture, - defaults_cache=defaults_cache, - lenient_check=lenient_check, - load_value_mode=load_value_mode, - class_instantiators=class_instantiators, - nested_links=nested_links, - applied_instantiation_links=applied_instantiation_links, -) +parser_context_vars = { + "parent_parser": parent_parser, + "parser_capture": parser_capture, + "defaults_cache": defaults_cache, + "lenient_check": lenient_check, + "load_value_mode": load_value_mode, + "class_instantiators": class_instantiators, + "nested_links": nested_links, + "applied_instantiation_links": applied_instantiation_links, +} @contextmanager @@ -91,10 +91,10 @@ def parser_context(**kwargs): context_var.reset(token) -parsing_settings = dict( - validate_defaults=False, - parse_optionals_as_positionals=False, -) +parsing_settings = { + "validate_defaults": False, + "parse_optionals_as_positionals": False, +} def set_parsing_settings( @@ -270,7 +270,7 @@ def __init__(self, instantiators: InstantiatorsDictType) -> None: def __call__(self, class_type: Type[ClassType], *args, **kwargs) -> ClassType: for (cls, subclasses), instantiator in self.instantiators.items(): if class_type is cls or (subclasses and is_subclass(class_type, cls)): - param_names = set(inspect.signature(instantiator).parameters.keys()) + param_names = set(inspect.signature(instantiator).parameters) if "applied_instantiation_links" in param_names: applied_links = applied_instantiation_links.get() or set() kwargs["applied_instantiation_links"] = { @@ -316,7 +316,7 @@ def setup_default_logger(data, level, caller): def parse_logger(logger: Union[bool, str, dict, logging.Logger], caller): if not isinstance(logger, (bool, str, dict, logging.Logger)): raise ValueError(f"Expected logger to be an instance of (bool, str, dict, logging.Logger), but got {logger}.") - if isinstance(logger, dict) and len(set(logger.keys()) - {"name", "level"}) > 0: + if isinstance(logger, dict) and len(set(logger) - {"name", "level"}) > 0: value = {k: v for k, v in logger.items() if k not in {"name", "level"}} raise ValueError(f"Unexpected data to configure logger: {value}.") if logger is False: @@ -384,6 +384,6 @@ class Action(LoggerProperty, argparse.Action): def _check_type_(self, value, **kwargs): if not hasattr(self, "_check_type_kwargs"): - self._check_type_kwargs = set(inspect.signature(self._check_type).parameters.keys()) + self._check_type_kwargs = set(inspect.signature(self._check_type).parameters) kwargs = {k: v for k, v in kwargs.items() if k in self._check_type_kwargs} return self._check_type(value, **kwargs) diff --git a/jsonargparse/_core.py b/jsonargparse/_core.py index b401124e..499dd488 100644 --- a/jsonargparse/_core.py +++ b/jsonargparse/_core.py @@ -222,7 +222,7 @@ class ArgumentGroup(ActionsContainer, argparse._ArgumentGroup): """Extension of argparse._ArgumentGroup to support additional functionalities.""" dest: Optional[str] = None - parser: Optional[Union["ArgumentParser", "ActionsContainer"]] = None + parser: Optional[Union["ArgumentParser", ActionsContainer]] = None class ArgumentParser(ParserDeprecations, ActionsContainer, ArgumentLinking, LoggerProperty, argparse.ArgumentParser): @@ -1352,9 +1352,9 @@ def _apply_actions( cfg_branch = cfg cfg = Namespace() cfg[parent_key] = cfg_branch - keys = [parent_key + "." + k for k in cfg_branch.__dict__.keys()] + keys = [parent_key + "." + k for k in cfg_branch.__dict__] else: - keys = list(cfg.__dict__.keys()) + keys = list(cfg.__dict__) if prev_cfg: prev_cfg = prev_cfg.clone() @@ -1594,7 +1594,7 @@ def parser_mode(self, parser_mode: str): if parser_mode == "omegaconf": set_omegaconf_loader() if parser_mode not in loaders: - raise ValueError(f"The only accepted values for parser_mode are {set(loaders.keys())}.") + raise ValueError(f"The only accepted values for parser_mode are {set(loaders)}.") if parser_mode == "jsonnet": import_jsonnet("parser_mode=jsonnet") self._parser_mode = parser_mode diff --git a/jsonargparse/_deprecated.py b/jsonargparse/_deprecated.py index cd4e0278..17633b70 100644 --- a/jsonargparse/_deprecated.py +++ b/jsonargparse/_deprecated.py @@ -553,7 +553,7 @@ def __init__(self, *args, error_handler=False, **kwargs): self.error_handler = error_handler @property - def error_handler(self) -> Optional[Callable[["ArgumentParser", str], None]]: + def error_handler(self) -> Optional[Callable[[ArgumentParser, str], None]]: """Property for the error_handler function that is called when there are parsing errors. :getter: Returns the current error_handler function. @@ -601,7 +601,7 @@ def check_config(self, *args, **kwargs): def deprecated_skip_check(component, kwargs: dict, skip_validation: bool) -> bool: skip_check = kwargs.pop("skip_check", None) if kwargs: - raise ValueError(f"Unexpected keyword parameters: {set(kwargs.keys())}") + raise ValueError(f"Unexpected keyword parameters: {set(kwargs)}") if skip_check is not None: skip_validation = skip_check deprecation_warning( diff --git a/jsonargparse/_formatters.py b/jsonargparse/_formatters.py index 24c8c50f..3d662150 100644 --- a/jsonargparse/_formatters.py +++ b/jsonargparse/_formatters.py @@ -288,7 +288,7 @@ def set_yaml_argument_comment( def get_env_var( - parser_or_formatter: Union["ArgumentParser", DefaultHelpFormatter], + parser_or_formatter: Union[ArgumentParser, DefaultHelpFormatter], action: Optional[Action] = None, ) -> str: """Returns the environment variable name for a given parser or formatter and action.""" diff --git a/jsonargparse/_loaders_dumpers.py b/jsonargparse/_loaders_dumpers.py index c0064d1c..db8211c4 100644 --- a/jsonargparse/_loaders_dumpers.py +++ b/jsonargparse/_loaders_dumpers.py @@ -87,11 +87,11 @@ def yaml_load(stream): value = yaml.load(stream, Loader=get_yaml_default_loader()) if isinstance(value, dict) and value and all(v is None for v in value.values()): - if len(value) == 1 and stream.strip() == next(iter(value.keys())) + ":": + if len(value) == 1 and stream.strip() == next(iter(value)) + ":": value = stream else: keys = set(stream.strip(" {}").replace(" ", "").split(",")) - if len(keys) > 0 and keys == set(value.keys()): + if len(keys) > 0 and keys == set(value): value = stream return value @@ -284,7 +284,7 @@ def dump_using_format(parser: ArgumentParser, data: dict, dump_format: str) -> s def set_loader( mode: str, loader_fn: Callable[[str], Any], - exceptions: Tuple[Type[Exception], ...] = tuple(), + exceptions: Tuple[Type[Exception], ...] = (), json_superset: bool = True, ): """Sets the value loader function to be used when parsing with a certain mode. diff --git a/jsonargparse/_namespace.py b/jsonargparse/_namespace.py index c0116fda..19f0d1a7 100644 --- a/jsonargparse/_namespace.py +++ b/jsonargparse/_namespace.py @@ -332,11 +332,11 @@ def del_clash_mark(key: str) -> str: def expand_dict(cfg): for k, v in cfg.items(): - if isinstance(v, dict) and all(isinstance(k, str) for k in v.keys()): + if isinstance(v, dict) and all(isinstance(k, str) for k in v): cfg[k] = expand_dict(v) elif isinstance(v, list): for nn, vv in enumerate(v): - if isinstance(vv, dict) and all(isinstance(k, str) for k in vv.keys()): + if isinstance(vv, dict) and all(isinstance(k, str) for k in vv): cfg[k][nn] = expand_dict(vv) return Namespace(**cfg) diff --git a/jsonargparse/_parameter_resolvers.py b/jsonargparse/_parameter_resolvers.py index 2bcaf6c9..bc607f3f 100644 --- a/jsonargparse/_parameter_resolvers.py +++ b/jsonargparse/_parameter_resolvers.py @@ -172,7 +172,7 @@ def ast_is_call_with_value(node, value_dump) -> bool: ast_constant_attr = {ast.Constant: "value"} -ast_constant_types = tuple(ast_constant_attr.keys()) +ast_constant_types = tuple(ast_constant_attr) def ast_is_constant(node): @@ -324,7 +324,7 @@ def unpack_typed_dict_kwargs(params: ParamList, kwargs_idx: int) -> int: annotation = kwargs.annotation if is_unpack_typehint(annotation): params.pop(kwargs_idx) - annotation_args: tuple = getattr(annotation, "__args__", tuple()) + annotation_args: tuple = getattr(annotation, "__args__", ()) assert len(annotation_args) == 1, "Unpack requires a single type argument" dict_annotations = annotation_args[0].__annotations__ new_params = [] @@ -710,7 +710,7 @@ def replace_param_default_subclass_specs(self, params: List[ParamData]) -> None: subclass_types = get_subclass_types(param.annotation, callable_return=True) if not (class_type and subclass_types and is_subclass(class_type, subclass_types)): continue - subclass_spec: dict = dict(class_path=get_import_path(class_type), init_args=dict()) + subclass_spec: dict = {"class_path": get_import_path(class_type), "init_args": {}} for kwarg in node.keywords: if kwarg.arg and ast_is_constant(kwarg.value): subclass_spec["init_args"][kwarg.arg] = ast_get_constant_value(kwarg.value) @@ -890,11 +890,11 @@ def get_field_data_pydantic1_model(field, name, doc_params): elif field.default_factory: default = field.default_factory() - return dict( - annotation=field.annotation, - default=default, - doc=field.field_info.description or doc_params.get(name), - ) + return { + "annotation": field.annotation, + "default": default, + "doc": field.field_info.description or doc_params.get(name), + } def get_field_data_pydantic2_dataclass(field, name, doc_params): @@ -921,11 +921,11 @@ def get_field_data_pydantic2_dataclass(field, name, doc_params): field_type = get_annotated_base_type(field.type) else: field_type = field.type - return dict( - annotation=field_type, - default=default, - doc=doc_params.get(name), - ) + return { + "annotation": field_type, + "default": default, + "doc": doc_params.get(name), + } def get_field_data_pydantic2_model(field, name, doc_params): @@ -935,11 +935,11 @@ def get_field_data_pydantic2_model(field, name, doc_params): elif field.default_factory: default = field.default_factory() - return dict( - annotation=field.rebuild_annotation(), - default=default, - doc=field.description or doc_params.get(name), - ) + return { + "annotation": field.rebuild_annotation(), + "default": default, + "doc": field.description or doc_params.get(name), + } def get_field_data_attrs(field, name, doc_params): @@ -951,11 +951,11 @@ def get_field_data_attrs(field, name, doc_params): elif isinstance(default, attrs.Factory): default = default.factory() - return dict( - annotation=field.type, - default=default, - doc=doc_params.get(name), - ) + return { + "annotation": field.type, + "default": default, + "doc": doc_params.get(name), + } def is_init_field_pydantic2_dataclass(field) -> bool: diff --git a/jsonargparse/_signatures.py b/jsonargparse/_signatures.py index 7c6586b3..fa144690 100644 --- a/jsonargparse/_signatures.py +++ b/jsonargparse/_signatures.py @@ -122,7 +122,7 @@ def add_class_arguments( defaults = default.lazy_get_init_args().as_dict() elif is_dataclass_like(default.__class__): defaults = dataclass_to_dict(default) - args = set(k[len(prefix) :] for k in added_args) + args = {k[len(prefix) :] for k in added_args} skip_not_added = [k for k in defaults if k not in args] if skip_not_added: skip.update(skip_not_added) # skip init=False diff --git a/jsonargparse/_typehints.py b/jsonargparse/_typehints.py index ae9a7981..64af9aa5 100644 --- a/jsonargparse/_typehints.py +++ b/jsonargparse/_typehints.py @@ -680,10 +680,10 @@ def completer(self, prefix, **kwargs): return ["true", "false", "null"] elif is_subclass(self._typehint, Enum): enum = self._typehint - return list(enum.__members__.keys()) + return list(enum.__members__) elif is_optional(self._typehint, Enum): enum = get_optional_arg(self._typehint) - return list(enum.__members__.keys()) + ["null"] + return list(enum.__members__) + ["null"] elif is_optional(self._typehint, Path): files_completer = get_files_completer() return ["null"] + sorted(files_completer(prefix, **kwargs)) @@ -773,7 +773,7 @@ def adapt_typehints( # Literal elif typehint_origin in literal_types: if val not in subtypehints and isinstance(val, str): - subtypes = Union[tuple({type(v) for v in subtypehints if type(v) is not str})] + subtypes = Union[tuple((type(v) for v in subtypehints if type(v) is not str))] val = adapt_typehints(val, subtypes, **adapt_kwargs) if val not in subtypehints: raise_unexpected_value(f"Expected a {typehint}", val) @@ -1451,7 +1451,7 @@ def adapt_class_type( value["init_args"] = load_value(parser.dump(init_args, **dump_kwargs.get())) else: if isinstance(dict_kwargs, dict): - for key in list(dict_kwargs.keys()): + for key in list(dict_kwargs): if _find_action(parser, key): init_args[key] = dict_kwargs.pop(key) elif dict_kwargs: @@ -1576,7 +1576,7 @@ def typehint_metavar(typehint): metavar = iter_to_set_str(enum.__members__) elif is_optional(typehint, Enum): enum = typehint.__args__[0] - metavar = iter_to_set_str(list(enum.__members__.keys()) + ["null"]) + metavar = iter_to_set_str(list(enum.__members__) + ["null"]) elif typehint_origin in tuple_set_origin_types: metavar = "[ITEM,...]" return metavar diff --git a/jsonargparse/_util.py b/jsonargparse/_util.py index b6b3a435..1b16f59e 100644 --- a/jsonargparse/_util.py +++ b/jsonargparse/_util.py @@ -353,7 +353,7 @@ def indent_text(text: str, first_line: bool = True) -> str: def get_private_kwargs(data, **kwargs): extracted = [data.pop(name, default) for name, default in kwargs.items()] if data: - raise ValueError(f"Unexpected keyword parameters: {set(data.keys())}") + raise ValueError(f"Unexpected keyword parameters: {set(data)}") return extracted[0] if len(extracted) == 1 else extracted diff --git a/jsonargparse_tests/test_core.py b/jsonargparse_tests/test_core.py index 3b748a1d..cbef2a8a 100644 --- a/jsonargparse_tests/test_core.py +++ b/jsonargparse_tests/test_core.py @@ -896,7 +896,7 @@ def test_default_config_files_pattern(parser, subtests, tmp_cwd): def test_named_argument_groups(parser): parser.add_argument_group("Group 1", name="group1") parser.add_argument_group("Group 2", name="group2") - assert {"group1", "group2"} == set(parser.groups.keys()) + assert {"group1", "group2"} == set(parser.groups) with pytest.raises(ValueError) as ctx: parser.add_argument_group("Bad", name="group1") ctx.match("Group with name group1 already exists") diff --git a/jsonargparse_tests/test_parameter_resolvers.py b/jsonargparse_tests/test_parameter_resolvers.py index 368e58fe..5ecd2621 100644 --- a/jsonargparse_tests/test_parameter_resolvers.py +++ b/jsonargparse_tests/test_parameter_resolvers.py @@ -554,7 +554,7 @@ def assert_params(params, expected, origins={}, help=True): if help: docs = [f"help for {p.name}" for p in params] if docstring_parser_support else [None] * len(params) assert docs == [p.doc for p in params] - assert all(isinstance(params[n].default, ConditionalDefault) for n in origins.keys()) + assert all(isinstance(params[n].default, ConditionalDefault) for n in origins) param_origins = { n: [o.split(f"{__name__}.", 1)[1] for o in p.origin] for n, p in enumerate(params) if p.origin is not None } diff --git a/jsonargparse_tests/test_postponed_annotations.py b/jsonargparse_tests/test_postponed_annotations.py index 0ebfba70..c7af175a 100644 --- a/jsonargparse_tests/test_postponed_annotations.py +++ b/jsonargparse_tests/test_postponed_annotations.py @@ -222,7 +222,7 @@ def function_type_checking_union(p1: Union[bool, TypeCheckingClass1, int], p2: U def test_get_types_type_checking_union(): types = get_types(function_type_checking_union) - assert list(types.keys()) == ["p1", "p2"] + assert list(types) == ["p1", "p2"] assert str(types["p1"]) == f"typing.Union[bool, {__name__}.TypeCheckingClass1, int]" assert str(types["p2"]) == f"typing.Union[float, {__name__}.TypeCheckingClass2]" @@ -233,7 +233,7 @@ def function_type_checking_alias(p1: type_checking_alias, p2: "type_checking_ali def test_get_types_type_checking_alias(): types = get_types(function_type_checking_alias) - assert list(types.keys()) == ["p1", "p2"] + assert list(types) == ["p1", "p2"] assert str(types["p1"]) == f"typing.Union[int, {__name__}.TypeCheckingClass2, typing.List[str]]" assert str(types["p2"]) == f"typing.Union[int, {__name__}.TypeCheckingClass2, typing.List[str]]" @@ -244,7 +244,7 @@ def function_type_checking_optional_alias(p1: type_checking_alias | None, p2: Op def test_get_types_type_checking_optional_alias(): types = get_types(function_type_checking_optional_alias) - assert list(types.keys()) == ["p1", "p2"] + assert list(types) == ["p1", "p2"] assert str(types["p1"]) == f"typing.Union[int, {__name__}.TypeCheckingClass2, typing.List[str], NoneType]" assert str(types["p2"]) == f"typing.Union[int, {__name__}.TypeCheckingClass2, typing.List[str], NoneType]" @@ -255,7 +255,7 @@ def function_type_checking_list(p1: List[Union["TypeCheckingClass1", TypeCheckin def test_get_types_type_checking_list(): types = get_types(function_type_checking_list) - assert list(types.keys()) == ["p1"] + assert list(types) == ["p1"] lst = "typing.List" assert str(types["p1"]) == f"{lst}[typing.Union[{__name__}.TypeCheckingClass1, {__name__}.TypeCheckingClass2]]" @@ -266,7 +266,7 @@ def function_type_checking_tuple(p1: Tuple[TypeCheckingClass1, "TypeCheckingClas def test_get_types_type_checking_tuple(): types = get_types(function_type_checking_tuple) - assert list(types.keys()) == ["p1"] + assert list(types) == ["p1"] tpl = "typing.Tuple" assert str(types["p1"]) == f"{tpl}[{__name__}.TypeCheckingClass1, {__name__}.TypeCheckingClass2]" @@ -277,7 +277,7 @@ def function_type_checking_type(p1: Type["TypeCheckingClass2"]): def test_get_types_type_checking_type(): types = get_types(function_type_checking_type) - assert list(types.keys()) == ["p1"] + assert list(types) == ["p1"] tpl = "typing.Type" assert str(types["p1"]) == f"{tpl}[{__name__}.TypeCheckingClass2]" @@ -288,7 +288,7 @@ def function_type_checking_dict(p1: Dict[str, Union[TypeCheckingClass1, "TypeChe def test_get_types_type_checking_dict(): types = get_types(function_type_checking_dict) - assert list(types.keys()) == ["p1"] + assert list(types) == ["p1"] dct = "typing.Dict" assert str(types["p1"]) == f"{dct}[str, typing.Union[{__name__}.TypeCheckingClass1, {__name__}.TypeCheckingClass2]]" diff --git a/jsonargparse_tests/test_subcommands.py b/jsonargparse_tests/test_subcommands.py index 1b351fcf..6c61f4a9 100644 --- a/jsonargparse_tests/test_subcommands.py +++ b/jsonargparse_tests/test_subcommands.py @@ -293,7 +293,7 @@ def test_subcommand_default_config_add_subdefaults(parser, subparser, tmp_cwd): subcommands.add_subcommand("fit", subparser) cfg = parser.parse_args([]) assert cfg.fit.model.class_path == f"{__name__}.Model" - assert list(cfg.fit.model.init_args.__dict__.keys()) == ["submodel"] + assert list(cfg.fit.model.init_args.__dict__) == ["submodel"] assert cfg.fit.model.init_args.submodel.class_path == f"{__name__}.SubModel" assert cfg.fit.model.init_args.submodel.init_args == Namespace(p1=1, p2="-") init = parser.instantiate_classes(cfg)