From 4dc2ff878aee87a0606f0b08c7e38401123da9e5 Mon Sep 17 00:00:00 2001 From: Mauricio Villegas <5780272+mauvilsa@users.noreply.github.com> Date: Wed, 21 Jun 2023 05:20:23 +0200 Subject: [PATCH] Added _ prefix to module names to be explicit about non-public API. --- .pre-commit-config.yaml | 2 + CHANGELOG.rst | 9 ++ jsonargparse/__init__.py | 88 ++++++++------- jsonargparse/{actions.py => _actions.py} | 16 +-- jsonargparse/{cli.py => _cli.py} | 10 +- jsonargparse/_common.py | 6 +- jsonargparse/{core.py => _core.py} | 32 +++--- .../{deprecated.py => _deprecated.py} | 105 +++++++++++++----- .../{formatters.py => _formatters.py} | 14 +-- jsonargparse/{jsonnet.py => _jsonnet.py} | 10 +- .../{jsonschema.py => _jsonschema.py} | 10 +- .../{link_arguments.py => _link_arguments.py} | 18 +-- ...loaders_dumpers.py => _loaders_dumpers.py} | 8 +- jsonargparse/{namespace.py => _namespace.py} | 0 jsonargparse/{optionals.py => _optionals.py} | 2 +- ...r_resolvers.py => _parameter_resolvers.py} | 12 +- .../{signatures.py => _signatures.py} | 10 +- jsonargparse/_stubs_resolver.py | 4 +- .../{type_checking.py => _type_checking.py} | 2 +- jsonargparse/{typehints.py => _typehints.py} | 20 ++-- jsonargparse/{util.py => _util.py} | 13 ++- jsonargparse/typing.py | 6 +- jsonargparse_tests/__init__.py | 2 +- jsonargparse_tests/conftest.py | 2 +- jsonargparse_tests/test_cli.py | 8 +- jsonargparse_tests/test_core.py | 2 +- jsonargparse_tests/test_dataclass_like.py | 4 +- jsonargparse_tests/test_deprecated.py | 67 +++++++++-- jsonargparse_tests/test_jsonnet.py | 2 +- jsonargparse_tests/test_loaders_dumpers.py | 8 +- jsonargparse_tests/test_namespace.py | 2 +- jsonargparse_tests/test_optionals.py | 2 +- .../test_parameter_resolvers.py | 6 +- jsonargparse_tests/test_signatures.py | 4 +- jsonargparse_tests/test_stubs_resolver.py | 4 +- jsonargparse_tests/test_typehints.py | 6 +- jsonargparse_tests/test_util.py | 6 +- 37 files changed, 315 insertions(+), 207 deletions(-) rename jsonargparse/{actions.py => _actions.py} (98%) rename jsonargparse/{cli.py => _cli.py} (96%) rename jsonargparse/{core.py => _core.py} (98%) rename jsonargparse/{deprecated.py => _deprecated.py} (85%) rename jsonargparse/{formatters.py => _formatters.py} (97%) rename jsonargparse/{jsonnet.py => _jsonnet.py} (96%) rename jsonargparse/{jsonschema.py => _jsonschema.py} (96%) rename jsonargparse/{link_arguments.py => _link_arguments.py} (97%) rename jsonargparse/{loaders_dumpers.py => _loaders_dumpers.py} (97%) rename jsonargparse/{namespace.py => _namespace.py} (100%) rename jsonargparse/{optionals.py => _optionals.py} (99%) rename jsonargparse/{parameter_resolvers.py => _parameter_resolvers.py} (99%) rename jsonargparse/{signatures.py => _signatures.py} (98%) rename jsonargparse/{type_checking.py => _type_checking.py} (83%) rename jsonargparse/{typehints.py => _typehints.py} (99%) rename jsonargparse/{util.py => _util.py} (98%) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index ec75a11e..2ed0701c 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,3 +1,5 @@ +fail_fast: true + ci: skip: - mypy diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 699ad600..e9b416d2 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -30,6 +30,15 @@ Fixed - Stop subclass dive if you hit bad import (`#304 `__). +Changed +^^^^^^^ +- Added ``_`` prefix to module names to be explicit about non-public API. + +Deprecated +^^^^^^^^^^ +- Importing from original non-public module paths (without ``_`` prefix) now + gives a ``DeprecationWarning``. From v5.0.0 these imports will fail. + v4.21.2 (2023-06-08) -------------------- diff --git a/jsonargparse/__init__.py b/jsonargparse/__init__.py index e3505833..d6b7743f 100644 --- a/jsonargparse/__init__.py +++ b/jsonargparse/__init__.py @@ -8,20 +8,21 @@ ArgumentError, ) -from .actions import * # noqa: F403 -from .cli import * # noqa: F403 -from .core import * # noqa: F403 -from .deprecated import * # noqa: F403 -from .formatters import * # noqa: F403 -from .jsonnet import * # noqa: F403 -from .jsonschema import * # noqa: F403 -from .link_arguments import * # noqa: F403 -from .loaders_dumpers import * # noqa: F403 -from .namespace import * # noqa: F403 -from .optionals import * # noqa: F403 -from .signatures import * # noqa: F403 -from .typehints import * # noqa: F403 -from .util import * # noqa: F403 +from ._actions import * # noqa: F403 +from ._cli import * # noqa: F403 +from ._core import * # noqa: F403 +from ._deprecated import * # noqa: F403 +from ._deprecated import py36_set_deprecated_module_attributes +from ._formatters import * # noqa: F403 +from ._jsonnet import * # noqa: F403 +from ._jsonschema import * # noqa: F403 +from ._link_arguments import * # noqa: F403 +from ._loaders_dumpers import * # noqa: F403 +from ._namespace import * # noqa: F403 +from ._optionals import * # noqa: F403 +from ._signatures import * # noqa: F403 +from ._typehints import * # noqa: F403 +from ._util import * # noqa: F403 __all__ = [ "ArgumentError", @@ -35,36 +36,39 @@ from . import ( - actions, - cli, - core, - deprecated, - formatters, - jsonnet, - jsonschema, - link_arguments, - loaders_dumpers, - namespace, - optionals, - signatures, - typehints, - util, + _actions, + _cli, + _core, + _deprecated, + _formatters, + _jsonnet, + _jsonschema, + _link_arguments, + _loaders_dumpers, + _namespace, + _optionals, + _signatures, + _typehints, + _util, ) -__all__ += cli.__all__ -__all__ += core.__all__ -__all__ += signatures.__all__ -__all__ += typehints.__all__ -__all__ += link_arguments.__all__ -__all__ += jsonschema.__all__ -__all__ += jsonnet.__all__ -__all__ += actions.__all__ -__all__ += namespace.__all__ -__all__ += formatters.__all__ -__all__ += optionals.__all__ -__all__ += loaders_dumpers.__all__ -__all__ += util.__all__ -__all__ += deprecated.__all__ +__all__ += _cli.__all__ +__all__ += _core.__all__ +__all__ += _signatures.__all__ +__all__ += _typehints.__all__ +__all__ += _link_arguments.__all__ +__all__ += _jsonschema.__all__ +__all__ += _jsonnet.__all__ +__all__ += _actions.__all__ +__all__ += _namespace.__all__ +__all__ += _formatters.__all__ +__all__ += _optionals.__all__ +__all__ += _loaders_dumpers.__all__ +__all__ += _util.__all__ +__all__ += _deprecated.__all__ __version__ = "4.21.2" + + +py36_set_deprecated_module_attributes(globals()) diff --git a/jsonargparse/actions.py b/jsonargparse/_actions.py similarity index 98% rename from jsonargparse/actions.py rename to jsonargparse/_actions.py index 3bfcd2c6..ebeff618 100644 --- a/jsonargparse/actions.py +++ b/jsonargparse/_actions.py @@ -10,11 +10,11 @@ from typing import Any, Dict, List, Optional, Tuple, Type, Union from ._common import is_subclass, parser_context -from .loaders_dumpers import get_loader_exceptions, load_value -from .namespace import Namespace, split_key, split_key_root -from .optionals import FilesCompleterMethod, get_config_read_mode -from .type_checking import ArgumentParser -from .util import ( +from ._loaders_dumpers import get_loader_exceptions, load_value +from ._namespace import Namespace, split_key, split_key_root +from ._optionals import FilesCompleterMethod, get_config_read_mode +from ._type_checking import ArgumentParser +from ._util import ( LoggerProperty, NoneType, Path, @@ -179,7 +179,7 @@ def set_default_error(): @staticmethod def apply_config(parser, cfg, dest, value) -> None: - from .link_arguments import skip_apply_links + from ._link_arguments import skip_apply_links with _ActionSubCommands.not_single_subcommand(), previous_config_context(cfg), skip_apply_links(): kwargs = {"env": False, "defaults": False, "_skip_check": True, "_fail_no_subcommand": False} @@ -334,7 +334,7 @@ def __init__(self, baseclass=None, **kwargs): def update_init_kwargs(self, kwargs): if get_typehint_origin(self._baseclass) == Union: - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint self._basename = iter_to_set_str( c.__name__ for c in self._baseclass.__args__ if ActionTypeHint.is_subclass_typehint(c) @@ -357,7 +357,7 @@ def __call__(self, *args, **kwargs): return self.print_help(args, self._baseclass, dest) def print_help(self, call_args, baseclass, dest): - from .typehints import resolve_class_path_by_name + from ._typehints import resolve_class_path_by_name parser, _, value, option_string = call_args try: diff --git a/jsonargparse/cli.py b/jsonargparse/_cli.py similarity index 96% rename from jsonargparse/cli.py rename to jsonargparse/_cli.py index 56e00005..d832f776 100644 --- a/jsonargparse/cli.py +++ b/jsonargparse/_cli.py @@ -3,11 +3,11 @@ import inspect from typing import Any, Callable, Dict, List, Optional, Type, Union -from .actions import ActionConfigFile, _ActionPrintConfig, remove_actions -from .core import ArgumentParser -from .deprecated import deprecation_warning_cli_return_parser -from .optionals import get_doc_short_description -from .util import default_config_option_help +from ._actions import ActionConfigFile, _ActionPrintConfig, remove_actions +from ._core import ArgumentParser +from ._deprecated import deprecation_warning_cli_return_parser +from ._optionals import get_doc_short_description +from ._util import default_config_option_help __all__ = ["CLI"] diff --git a/jsonargparse/_common.py b/jsonargparse/_common.py index 9dc6cf06..2b9a48e2 100644 --- a/jsonargparse/_common.py +++ b/jsonargparse/_common.py @@ -4,8 +4,8 @@ from contextvars import ContextVar from typing import Optional, Union -from .namespace import Namespace -from .type_checking import ArgumentParser +from ._namespace import Namespace +from ._type_checking import ArgumentParser parent_parser: ContextVar["ArgumentParser"] = ContextVar("parent_parser") parser_capture: ContextVar[bool] = ContextVar("parser_capture", default=False) @@ -57,7 +57,7 @@ def is_dataclass_like(cls) -> bool: return True classes = [c for c in inspect.getmro(cls) if c != object] all_dataclasses = all(dataclasses.is_dataclass(c) for c in classes) - from .optionals import attrs_support, pydantic_support + from ._optionals import attrs_support, pydantic_support if not all_dataclasses and pydantic_support: import pydantic.utils diff --git a/jsonargparse/core.py b/jsonargparse/_core.py similarity index 98% rename from jsonargparse/core.py rename to jsonargparse/_core.py index b9a61746..fdaccad6 100644 --- a/jsonargparse/core.py +++ b/jsonargparse/_core.py @@ -22,8 +22,7 @@ Union, ) -from ._common import is_dataclass_like, is_subclass, lenient_check, parser_context -from .actions import ( +from ._actions import ( ActionConfigFile, ActionParser, _ActionConfigLoad, @@ -39,12 +38,13 @@ parent_parsers, previous_config, ) -from .deprecated import ParserDeprecations -from .formatters import DefaultHelpFormatter, empty_help, get_env_var -from .jsonnet import ActionJsonnet, ActionJsonnetExtVars -from .jsonschema import ActionJsonSchema -from .link_arguments import ActionLink, ArgumentLinking -from .loaders_dumpers import ( +from ._common import is_dataclass_like, is_subclass, lenient_check, parser_context +from ._deprecated import ParserDeprecations +from ._formatters import DefaultHelpFormatter, empty_help, get_env_var +from ._jsonnet import ActionJsonnet, ActionJsonnetExtVars +from ._jsonschema import ActionJsonSchema +from ._link_arguments import ActionLink, ArgumentLinking +from ._loaders_dumpers import ( check_valid_dump_format, dump_using_format, get_loader_exceptions, @@ -53,7 +53,7 @@ set_omegaconf_loader, yaml_load, ) -from .namespace import ( +from ._namespace import ( Namespace, is_meta_key, patch_namespace, @@ -62,7 +62,7 @@ split_key_leaf, strip_meta, ) -from .optionals import ( +from ._optionals import ( argcomplete_autocomplete, argcomplete_namespace, fsspec_support, @@ -70,10 +70,10 @@ import_fsspec, import_jsonnet, ) -from .parameter_resolvers import UnknownDefault -from .signatures import SignatureArguments -from .typehints import ActionTypeHint, is_subclass_spec -from .util import ( +from ._parameter_resolvers import UnknownDefault +from ._signatures import SignatureArguments +from ._typehints import ActionTypeHint, is_subclass_spec +from ._util import ( Path, argument_error, change_to_path_dir, @@ -1401,7 +1401,7 @@ def env_prefix(self) -> Union[bool, str]: @env_prefix.setter def env_prefix(self, env_prefix: Union[bool, str]): if env_prefix is None: - from .deprecated import ( + from ._deprecated import ( deprecation_warning, env_prefix_property_none_message, ) @@ -1460,7 +1460,7 @@ def dump_header(self, dump_header: Optional[List[str]]): self._dump_header = dump_header -from .deprecated import instantiate_subclasses_patch, parse_as_dict_patch # noqa: E402 +from ._deprecated import instantiate_subclasses_patch, parse_as_dict_patch # noqa: E402 instantiate_subclasses_patch() if "SPHINX_BUILD" not in os.environ: diff --git a/jsonargparse/deprecated.py b/jsonargparse/_deprecated.py similarity index 85% rename from jsonargparse/deprecated.py rename to jsonargparse/_deprecated.py index cdb1b8f4..944bf57e 100644 --- a/jsonargparse/deprecated.py +++ b/jsonargparse/_deprecated.py @@ -6,11 +6,14 @@ import sys from argparse import Action, ArgumentError from enum import Enum +from importlib import import_module +from pathlib import Path +from types import ModuleType from typing import Any, Callable, Dict, Optional, Set -from .namespace import Namespace -from .optionals import FilesCompleterMethod -from .type_checking import ArgumentParser +from ._namespace import Namespace +from ._optionals import FilesCompleterMethod +from ._type_checking import ArgumentParser __all__ = [ "ActionEnum", @@ -35,7 +38,7 @@ def deprecation_warning(component, message): show_warnings = env_var != "off" all_warnings = env_var == "all" if show_warnings and (component not in shown_deprecation_warnings or all_warnings): - from .util import warning + from ._util import warning if len(shown_deprecation_warnings) == 0 and not all_warnings: warning( @@ -86,7 +89,7 @@ def parse_as_dict_patch(): cleaner code in v4.0.0 and warn users about the deprecation and future removal. """ - from .core import ArgumentParser + from ._core import ArgumentParser assert not hasattr(ArgumentParser, "_unpatched_init") @@ -176,7 +179,7 @@ def instantiate_subclasses(self, cfg: Namespace) -> Namespace: def instantiate_subclasses_patch(): - from .core import ArgumentParser + from ._core import ArgumentParser ArgumentParser.instantiate_subclasses = instantiate_subclasses @@ -201,7 +204,7 @@ def __init__(self, **kwargs): raise ValueError("Expected enum keyword argument.") def __call__(self, *args, **kwargs): - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint return ActionTypeHint(typehint=self._type)(**kwargs) @@ -231,7 +234,7 @@ def __init__(self, **kwargs): raise ValueError("Expected expr keyword argument.") def __call__(self, *args, **kwargs): - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint return ActionTypeHint(typehint=self._type)(**kwargs) @@ -255,7 +258,7 @@ def __init__( self._type = path_type(mode, skip_check=skip_check) def __call__(self, *args, **kwargs): - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint return ActionTypeHint(typehint=self._type)(**kwargs) @@ -311,7 +314,7 @@ def __call__(self, *args, **kwargs): def _check_type(self, value, cfg=None): if value == []: return value - from .actions import _is_action_value_list + from ._actions import _is_action_value_list islist = _is_action_value_list(self) if not islist and not isinstance(value, list): @@ -349,7 +352,7 @@ def _check_type(self, value, cfg=None): ) def set_url_support(enabled: bool): """Enables/disables URL support for config read mode.""" - from .optionals import get_config_read_mode, set_config_read_mode + from ._optionals import get_config_read_mode, set_config_read_mode set_config_read_mode( urls_enabled=enabled, @@ -378,21 +381,6 @@ def deprecation_warning_cli_return_parser(): """ -@deprecated( - """ - Only use the public API as described in - https://jsonargparse.readthedocs.io/en/stable/#api-reference. Keeping - import_docstring_parse function as deprecated only to provide backward - compatibility with old versions of pytorch-lightning. Will be removed in - v5.0.0. -""" -) -def import_docstring_parse(importer): - from .optionals import import_docstring_parser - - return import_docstring_parser(importer).parse - - path_skip_check_message = """ The skip_check parameter of Path was deprecated in v4.20.0 and will be removed in v5.0.0. There is no reason to use a Path type if its checks are @@ -444,7 +432,7 @@ def cwd(self, cwd): self._cwd = cwd def _deprecated_kwargs(self, kwargs): - from .util import get_private_kwargs + from ._util import get_private_kwargs self._skip_check = get_private_kwargs(kwargs, skip_check=False) if self._skip_check: @@ -529,6 +517,65 @@ def error_handler(self, error_handler): ParserError = ArgumentError -import jsonargparse.optionals # noqa: E402 +def deprecated_module(module_name, mappings=None): + module_path = f"jsonargparse.{module_name}" + module = ModuleType(module_path, f"deprecated {module_path}") + sys.modules[module_path] = module -jsonargparse.optionals.import_docstring_parse = import_docstring_parse # type: ignore + @deprecated( + f""" + Only use the public API as described in + https://jsonargparse.readthedocs.io/en/stable/#api-reference. Importing + from {module_path} is kept only to avoid breaking code that does not + correctly use the public API. It will no longer be available from v5.0.0. + """ + ) + def __getattr__(name): + new_module = f"_{module_name}" + if mappings and name in mappings: + new_module, name = mappings[name] + return getattr(import_module(f"jsonargparse.{new_module}"), name) + + module.__getattr__ = __getattr__ + module.__dict__["__file__"] = str(Path(__file__).parent / f"{module_name}.py") + module.__dict__["__path__"] = module_path + + if sys.version_info[:2] == (3, 6): + _py36_deprecated_modules[module_name] = (module, mappings) + + +_py36_deprecated_modules = {} # type: ignore + + +def py36_set_deprecated_module_attributes(globs): + for module_name, (module, mappings) in _py36_deprecated_modules.items(): + globs[module_name] = module + for name, value in vars(import_module(f"jsonargparse._{module_name}")).items(): + if name != "__all__" and name.startswith("_"): + continue + setattr(module, name, value) + for name, (new_module, new_name) in (mappings or {}).items(): + value = getattr(import_module(f"jsonargparse.{new_module}"), new_name) + setattr(module, name, value) + + +deprecated_module("actions") +deprecated_module("cli") +deprecated_module("core") +deprecated_module("deprecated") +deprecated_module("formatters") +deprecated_module("jsonnet") +deprecated_module("jsonschema") +deprecated_module("link_arguments") +deprecated_module("loaders_dumpers") +deprecated_module("namespace") +deprecated_module("parameter_resolvers") +deprecated_module("signatures") +deprecated_module("typehints") +deprecated_module("util") +deprecated_module( + "optionals", + { + "import_docstring_parse": ("_optionals", "import_docstring_parser"), + }, +) diff --git a/jsonargparse/formatters.py b/jsonargparse/_formatters.py similarity index 97% rename from jsonargparse/formatters.py rename to jsonargparse/_formatters.py index b3026e51..3912beb8 100644 --- a/jsonargparse/formatters.py +++ b/jsonargparse/_formatters.py @@ -13,8 +13,7 @@ from string import Template from typing import Iterable, Optional, Union -from ._common import defaults_cache, parent_parser -from .actions import ( +from ._actions import ( ActionConfigFile, ActionYesNo, _ActionConfigLoad, @@ -22,11 +21,12 @@ _find_action, filter_default_actions, ) -from .link_arguments import ActionLink -from .namespace import Namespace -from .optionals import import_ruyaml -from .type_checking import ArgumentParser, ruyamlCommentedMap -from .typehints import ActionTypeHint, type_to_str +from ._common import defaults_cache, parent_parser +from ._link_arguments import ActionLink +from ._namespace import Namespace +from ._optionals import import_ruyaml +from ._type_checking import ArgumentParser, ruyamlCommentedMap +from ._typehints import ActionTypeHint, type_to_str __all__ = ["DefaultHelpFormatter"] diff --git a/jsonargparse/jsonnet.py b/jsonargparse/_jsonnet.py similarity index 96% rename from jsonargparse/jsonnet.py rename to jsonargparse/_jsonnet.py index d3de7f49..80239a95 100644 --- a/jsonargparse/jsonnet.py +++ b/jsonargparse/_jsonnet.py @@ -2,17 +2,17 @@ from typing import Any, Dict, Optional, Tuple, Union +from ._actions import Action, _is_action_value_list from ._common import parser_context -from .actions import Action, _is_action_value_list -from .jsonschema import ActionJsonSchema -from .loaders_dumpers import get_loader_exceptions, load_value -from .optionals import ( +from ._jsonschema import ActionJsonSchema +from ._loaders_dumpers import get_loader_exceptions, load_value +from ._optionals import ( get_config_read_mode, get_jsonschema_exceptions, import_jsonnet, import_jsonschema, ) -from .util import Path, argument_error +from ._util import Path, argument_error __all__ = [ "ActionJsonnetExtVars", diff --git a/jsonargparse/jsonschema.py b/jsonargparse/_jsonschema.py similarity index 96% rename from jsonargparse/jsonschema.py rename to jsonargparse/_jsonschema.py index 044a18db..4b0c343a 100644 --- a/jsonargparse/jsonschema.py +++ b/jsonargparse/_jsonschema.py @@ -3,16 +3,16 @@ import os from typing import Dict, Optional, Union +from ._actions import Action, _is_action_value_list from ._common import parser_context -from .actions import Action, _is_action_value_list -from .loaders_dumpers import get_loader_exceptions, load_value -from .namespace import strip_meta -from .optionals import ( +from ._loaders_dumpers import get_loader_exceptions, load_value +from ._namespace import strip_meta +from ._optionals import ( argcomplete_warn_redraw_prompt, get_jsonschema_exceptions, import_jsonschema, ) -from .util import parse_value_or_config +from ._util import parse_value_or_config __all__ = ["ActionJsonSchema"] diff --git a/jsonargparse/link_arguments.py b/jsonargparse/_link_arguments.py similarity index 97% rename from jsonargparse/link_arguments.py rename to jsonargparse/_link_arguments.py index 68d1f781..9572046c 100644 --- a/jsonargparse/link_arguments.py +++ b/jsonargparse/_link_arguments.py @@ -9,7 +9,7 @@ from contextvars import ContextVar from typing import Any, Callable, List, Optional, Tuple, Type, Union -from .actions import ( +from ._actions import ( Action, ActionConfigFile, _ActionConfigLoad, @@ -17,8 +17,8 @@ _find_parent_action, filter_default_actions, ) -from .namespace import Namespace, split_key_leaf -from .type_checking import ArgumentParser, _ArgumentGroup +from ._namespace import Namespace, split_key_leaf +from ._type_checking import ArgumentParser, _ArgumentGroup __all__ = ["ArgumentLinking"] @@ -46,7 +46,7 @@ def find_subclass_action_or_class_group( key: str, exclude: Optional[Union[Type[ArgparseAction], Tuple[Type[ArgparseAction], ...]]] = None, ) -> Optional[Union[ArgparseAction, "_ArgumentGroup"]]: - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint action = _find_parent_action(parser, key, exclude=exclude) if ActionTypeHint.is_subclass_typehint(action): @@ -140,7 +140,7 @@ def __init__( raise ValueError(f'No action for key "{key}".') assert self.target[1] is not None - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint is_target_subclass = ActionTypeHint.is_subclass_typehint(self.target[1], all_subtypes=False) valid_target_init_arg = is_target_subclass and target.startswith(f"{self.target[1].dest}.init_args.") @@ -246,7 +246,7 @@ def apply_parsing_links(parser: "ArgumentParser", cfg: Namespace) -> None: for action in parser._links_group._group_actions: if action.apply_on != "parse": continue - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint args = [] skip_link = False @@ -310,7 +310,7 @@ def apply_instantiation_links(parser, cfg, target=None, order=None): source_objects.append(source_object) else: attr = split_key_leaf(source_key)[1] - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint if ActionTypeHint.is_subclass_typehint(source_action) and not hasattr(source_object, attr): parser.logger.debug( @@ -334,7 +334,7 @@ def apply_instantiation_links(parser, cfg, target=None, order=None): @staticmethod def set_target_value(action: "ActionLink", value: Any, cfg: Namespace, logger) -> None: target_key, target_action = action.target - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint if ActionTypeHint.is_subclass_typehint(target_action, all_subtypes=False): if target_key == target_action.dest: # type: ignore @@ -380,7 +380,7 @@ def del_taget_key(target_key): for action in [a for a in parser._actions if isinstance(a, ActionLink)]: del_taget_key(action.target[0]) - from .typehints import ActionTypeHint + from ._typehints import ActionTypeHint for action in [a for a in parser._actions if isinstance(a, ActionTypeHint) and hasattr(a, "sub_add_kwargs")]: for key in action.sub_add_kwargs.get("linked_targets", []): diff --git a/jsonargparse/loaders_dumpers.py b/jsonargparse/_loaders_dumpers.py similarity index 97% rename from jsonargparse/loaders_dumpers.py rename to jsonargparse/_loaders_dumpers.py index 71ddb55f..8e60b571 100644 --- a/jsonargparse/loaders_dumpers.py +++ b/jsonargparse/_loaders_dumpers.py @@ -7,8 +7,8 @@ import yaml from ._common import load_value_mode, parent_parser -from .optionals import import_jsonnet, omegaconf_support -from .type_checking import ArgumentParser +from ._optionals import import_jsonnet, omegaconf_support +from ._type_checking import ArgumentParser __all__ = [ "set_loader", @@ -65,7 +65,7 @@ def yaml_load(stream): def jsonnet_load(stream, path="", ext_vars=None): - from .jsonnet import ActionJsonnet + from ._jsonnet import ActionJsonnet ext_vars, ext_codes = ActionJsonnet.split_ext_vars(ext_vars) _jsonnet = import_jsonnet("jsonnet_load") @@ -211,6 +211,6 @@ def set_dumper(format_name: str, dumper_fn: Callable[[Any], str]): def set_omegaconf_loader(): if omegaconf_support and "omegaconf" not in loaders: - from .optionals import get_omegaconf_loader + from ._optionals import get_omegaconf_loader set_loader("omegaconf", get_omegaconf_loader()) diff --git a/jsonargparse/namespace.py b/jsonargparse/_namespace.py similarity index 100% rename from jsonargparse/namespace.py rename to jsonargparse/_namespace.py diff --git a/jsonargparse/optionals.py b/jsonargparse/_optionals.py similarity index 99% rename from jsonargparse/optionals.py rename to jsonargparse/_optionals.py index 7222ab1d..69a8508d 100644 --- a/jsonargparse/optionals.py +++ b/jsonargparse/_optionals.py @@ -286,7 +286,7 @@ def get_omegaconf_loader(): """Returns a yaml loader function based on OmegaConf which supports variable interpolation.""" import io - from .loaders_dumpers import yaml_load + from ._loaders_dumpers import yaml_load with missing_package_raise("omegaconf", "get_omegaconf_loader"): from omegaconf import OmegaConf diff --git a/jsonargparse/parameter_resolvers.py b/jsonargparse/_parameter_resolvers.py similarity index 99% rename from jsonargparse/parameter_resolvers.py rename to jsonargparse/_parameter_resolvers.py index 2fc7a86c..92a9690f 100644 --- a/jsonargparse/parameter_resolvers.py +++ b/jsonargparse/_parameter_resolvers.py @@ -11,9 +11,9 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union from ._common import is_dataclass_like, is_subclass +from ._optionals import parse_docs from ._stubs_resolver import get_stub_types -from .optionals import attrs_support, parse_docs, pydantic_support -from .util import ( +from ._util import ( ClassFromFunctionBase, LoggerProperty, get_import_path, @@ -328,7 +328,7 @@ def get_kwargs_pop_or_get_parameter(node, component, parent, doc_params, log_deb def is_param_subclass_instance_default(param: ParamData) -> bool: if is_dataclass_like(type(param.default)): return False - from .typehints import ActionTypeHint, get_subclass_types + from ._typehints import ActionTypeHint, get_subclass_types class_types = get_subclass_types(param.annotation) return (class_types and isinstance(param.default, class_types)) or ( @@ -601,7 +601,7 @@ def replace_param_default_subclass_specs(self, params: List[ParamData]) -> None: self.parse_source_tree() default_nodes = self.get_default_nodes({p.name for p in params}) assert len(params) == len(default_nodes) - from .typehints import get_subclass_types + from ._typehints import get_subclass_types for param, default_node in zip(params, default_nodes): lambda_default = is_lambda(param.default) @@ -774,7 +774,9 @@ def get_parameters_from_pydantic_or_attrs( method_or_property: Optional[str], logger: logging.Logger, ) -> Optional[ParamList]: - if method_or_property: + from ._optionals import attrs_support, pydantic_support + + if method_or_property or not (pydantic_support or attrs_support): return None fields_iterator = None diff --git a/jsonargparse/signatures.py b/jsonargparse/_signatures.py similarity index 98% rename from jsonargparse/signatures.py rename to jsonargparse/_signatures.py index e4da036d..9dd19952 100644 --- a/jsonargparse/signatures.py +++ b/jsonargparse/_signatures.py @@ -7,17 +7,17 @@ from contextlib import suppress from typing import Any, Callable, List, Optional, Set, Tuple, Type, Union +from ._actions import _ActionConfigLoad from ._common import is_dataclass_like, is_subclass -from .actions import _ActionConfigLoad -from .optionals import get_doc_short_description, pydantic_support -from .parameter_resolvers import ( +from ._optionals import get_doc_short_description, pydantic_support +from ._parameter_resolvers import ( ParamData, get_parameter_origins, get_signature_parameters, ) -from .typehints import ActionTypeHint, LazyInitBaseClass, is_optional +from ._typehints import ActionTypeHint, LazyInitBaseClass, is_optional +from ._util import LoggerProperty, get_import_path, iter_to_set_str from .typing import register_pydantic_type -from .util import LoggerProperty, get_import_path, iter_to_set_str __all__ = [ "compose_dataclasses", diff --git a/jsonargparse/_stubs_resolver.py b/jsonargparse/_stubs_resolver.py index 164ae05a..1211f85c 100644 --- a/jsonargparse/_stubs_resolver.py +++ b/jsonargparse/_stubs_resolver.py @@ -7,12 +7,12 @@ from pathlib import Path from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple -from .optionals import ( +from ._optionals import ( import_typeshed_client, typeshed_client_support, typing_extensions_import, ) -from .util import unique +from ._util import unique if TYPE_CHECKING: # pragma: no cover import typeshed_client as tc diff --git a/jsonargparse/type_checking.py b/jsonargparse/_type_checking.py similarity index 83% rename from jsonargparse/type_checking.py rename to jsonargparse/_type_checking.py index 7b33a490..6ceef996 100644 --- a/jsonargparse/type_checking.py +++ b/jsonargparse/_type_checking.py @@ -9,6 +9,6 @@ if TYPE_CHECKING: # pragma: no cover from ruyaml.comments import CommentedMap as ruyamlCommentedMap - from .core import ArgumentParser, _ArgumentGroup + from ._core import ArgumentParser, _ArgumentGroup else: globals().update({k: None for k in __all__}) diff --git a/jsonargparse/typehints.py b/jsonargparse/_typehints.py similarity index 99% rename from jsonargparse/typehints.py rename to jsonargparse/_typehints.py index 8c77b5de..ca0e1e53 100644 --- a/jsonargparse/typehints.py +++ b/jsonargparse/_typehints.py @@ -32,8 +32,7 @@ Union, ) -from ._common import is_dataclass_like, is_subclass, parent_parser, parser_context -from .actions import ( +from ._actions import ( Action, ActionConfigFile, _ActionHelpClassPath, @@ -43,20 +42,20 @@ _is_action_value_list, remove_actions, ) -from .loaders_dumpers import ( +from ._common import is_dataclass_like, is_subclass, parent_parser, parser_context +from ._loaders_dumpers import ( get_loader_exceptions, load_value, pyyaml_exceptions, yaml_load, ) -from .namespace import Namespace -from .optionals import ( +from ._namespace import Namespace +from ._optionals import ( argcomplete_warn_redraw_prompt, get_files_completer, typing_extensions_import, ) -from .typing import get_registered_type, is_pydantic_type -from .util import ( +from ._util import ( ClassType, NestedArg, NoneType, @@ -72,6 +71,7 @@ read_stdin, warning, ) +from .typing import get_registered_type, is_pydantic_type __all__ = ["lazy_instance"] @@ -693,7 +693,7 @@ def adapt_typehints( val = read_stdin().splitlines() else: with suppress(TypeError): - from .optionals import get_config_read_mode + from ._optionals import get_config_read_mode list_path = Path(val, mode=get_config_read_mode()) val = list_path.get_content().splitlines() @@ -781,7 +781,7 @@ def adapt_typehints( # Dataclass-like elif is_dataclass_like(typehint): if is_dataclass_like(type(prev_val)) and is_subclass(type(prev_val), typehint): - from .signatures import dataclass_to_dict + from ._signatures import dataclass_to_dict assert isinstance(sub_add_kwargs, dict) sub_add_kwargs["default"] = lazy_instance(type(prev_val), **dataclass_to_dict(prev_val)) @@ -1190,7 +1190,7 @@ def callable_instances(cls: Type): def check_lazy_kwargs(class_type: Type, lazy_kwargs: dict): if lazy_kwargs: - from .core import ArgumentParser + from ._core import ArgumentParser parser = ArgumentParser(exit_on_error=False) parser.add_class_arguments(class_type) diff --git a/jsonargparse/util.py b/jsonargparse/_util.py similarity index 98% rename from jsonargparse/util.py rename to jsonargparse/_util.py index c0eda988..7130bd53 100644 --- a/jsonargparse/util.py +++ b/jsonargparse/_util.py @@ -31,9 +31,9 @@ ) from ._common import parser_capture, parser_context -from .deprecated import PathDeprecations -from .loaders_dumpers import json_dump, load_value -from .optionals import ( +from ._deprecated import PathDeprecations +from ._loaders_dumpers import json_dump, load_value +from ._optionals import ( fsspec_support, get_config_read_mode, import_fsspec, @@ -42,7 +42,7 @@ reconplogger_support, url_support, ) -from .type_checking import ArgumentParser +from ._type_checking import ArgumentParser __all__ = [ "capture_parser", @@ -81,8 +81,9 @@ class JsonargparseWarning(UserWarning): def warning(message, category=JsonargparseWarning, stacklevel=1): + message = textwrap.fill(textwrap.dedent(message), 110).strip() warnings.warn( - re.sub("\n\n+", "\n\n", re.sub("\n +", "\n ", message)), + "\n" + textwrap.indent(message, " ") + "\n", category=category, stacklevel=stacklevel + 1, ) @@ -732,7 +733,7 @@ def logger(self) -> logging.Logger: @logger.setter def logger(self, logger: Union[bool, str, dict, logging.Logger]): if logger is None: - from .deprecated import deprecation_warning, logger_property_none_message + from ._deprecated import deprecation_warning, logger_property_none_message deprecation_warning((LoggerProperty.logger, None), logger_property_none_message) logger = False diff --git a/jsonargparse/typing.py b/jsonargparse/typing.py index f28ad2fe..e5c4cc50 100644 --- a/jsonargparse/typing.py +++ b/jsonargparse/typing.py @@ -9,8 +9,8 @@ from typing import Any, Callable, Dict, List, Optional, Pattern, Tuple, Type, Union from ._common import is_final_class, is_subclass -from .optionals import final, pydantic_support -from .util import Path, get_import_path, get_private_kwargs, import_object +from ._optionals import final, pydantic_support +from ._util import Path, get_import_path, get_private_kwargs, import_object __all__ = [ "final", @@ -213,7 +213,7 @@ def path_type(mode: str, docstring: Optional[str] = None, **kwargs) -> type: skip_check = get_private_kwargs(kwargs, skip_check=False) if skip_check: - from .deprecated import path_skip_check_deprecation + from ._deprecated import path_skip_check_deprecation path_skip_check_deprecation() name += "_skip_check" diff --git a/jsonargparse_tests/__init__.py b/jsonargparse_tests/__init__.py index 1649acc1..0aaa73c1 100644 --- a/jsonargparse_tests/__init__.py +++ b/jsonargparse_tests/__init__.py @@ -3,7 +3,7 @@ if "JSONARGPARSE_OMEGACONF_FULL_TEST" in os.environ: import warnings - from jsonargparse.loaders_dumpers import loaders, set_omegaconf_loader + from jsonargparse._loaders_dumpers import loaders, set_omegaconf_loader set_omegaconf_loader() if "omegaconf" in loaders: diff --git a/jsonargparse_tests/conftest.py b/jsonargparse_tests/conftest.py index 0add4e77..656efe33 100644 --- a/jsonargparse_tests/conftest.py +++ b/jsonargparse_tests/conftest.py @@ -11,7 +11,7 @@ import pytest from jsonargparse import ArgumentParser -from jsonargparse.optionals import ( +from jsonargparse._optionals import ( docstring_parser_support, fsspec_support, jsonschema_support, diff --git a/jsonargparse_tests/test_cli.py b/jsonargparse_tests/test_cli.py index 48db4bc0..d6a123c3 100644 --- a/jsonargparse_tests/test_cli.py +++ b/jsonargparse_tests/test_cli.py @@ -11,7 +11,7 @@ import yaml from jsonargparse import CLI, capture_parser, lazy_instance -from jsonargparse.optionals import docstring_parser_support, ruyaml_support +from jsonargparse._optionals import docstring_parser_support, ruyaml_support from jsonargparse.typing import final from jsonargparse_tests.conftest import skip_if_docstring_parser_unavailable @@ -290,7 +290,7 @@ def empty_context(): CLI() with patch("inspect.getmodule") as mock_getmodule: - mock_getmodule.return_value = sys.modules["jsonargparse.core"] + mock_getmodule.return_value = sys.modules["jsonargparse._core"] pytest.raises(ValueError, empty_context) @@ -302,7 +302,7 @@ def function(a1: float): return CLI(args=["6.7"]) with patch("inspect.getmodule") as mock_getmodule: - mock_getmodule.return_value = sys.modules["jsonargparse.core"] + mock_getmodule.return_value = sys.modules["jsonargparse._core"] assert 6.7 == non_empty_context_function() @@ -318,7 +318,7 @@ def method(self, m1: int): return CLI(args=["a", "method", "2"]) with patch("inspect.getmodule") as mock_getmodule: - mock_getmodule.return_value = sys.modules["jsonargparse.core"] + mock_getmodule.return_value = sys.modules["jsonargparse._core"] assert ("a", 2) == non_empty_context_class() diff --git a/jsonargparse_tests/test_core.py b/jsonargparse_tests/test_core.py index e4cff6d5..daf05788 100644 --- a/jsonargparse_tests/test_core.py +++ b/jsonargparse_tests/test_core.py @@ -24,7 +24,7 @@ set_config_read_mode, strip_meta, ) -from jsonargparse.optionals import jsonnet_support, jsonschema_support, ruyaml_support +from jsonargparse._optionals import jsonnet_support, jsonschema_support, ruyaml_support from jsonargparse.typing import Path_fc, Path_fr, path_type from jsonargparse_tests.conftest import ( capture_logs, diff --git a/jsonargparse_tests/test_dataclass_like.py b/jsonargparse_tests/test_dataclass_like.py index 0ad9b551..68d84c07 100644 --- a/jsonargparse_tests/test_dataclass_like.py +++ b/jsonargparse_tests/test_dataclass_like.py @@ -13,7 +13,7 @@ compose_dataclasses, lazy_instance, ) -from jsonargparse.optionals import ( +from jsonargparse._optionals import ( attrs_support, docstring_parser_support, pydantic_support, @@ -270,7 +270,7 @@ class WithAttrDocs: @skip_if_docstring_parser_unavailable -@patch.dict("jsonargparse.optionals._docstring_parse_options") +@patch.dict("jsonargparse._optionals._docstring_parse_options") def test_attribute_docstrings(parser): set_docstring_parse_options(attribute_docstrings=True) parser.add_class_arguments(WithAttrDocs) diff --git a/jsonargparse_tests/test_deprecated.py b/jsonargparse_tests/test_deprecated.py index 9995111d..b2926c36 100644 --- a/jsonargparse_tests/test_deprecated.py +++ b/jsonargparse_tests/test_deprecated.py @@ -1,8 +1,10 @@ import os import pathlib +import sys from calendar import Calendar from contextlib import contextmanager, redirect_stderr, redirect_stdout from enum import Enum +from importlib import import_module from io import StringIO from warnings import catch_warnings @@ -17,19 +19,18 @@ get_config_read_mode, set_url_support, ) -from jsonargparse.deprecated import ( +from jsonargparse._deprecated import ( ActionEnum, ActionOperators, ActionPath, ActionPathList, ParserError, deprecation_warning, - import_docstring_parse, shown_deprecation_warnings, usage_and_exit_error_handler, ) -from jsonargparse.optionals import url_support -from jsonargparse.util import LoggerProperty, argument_error +from jsonargparse._optionals import url_support +from jsonargparse._util import LoggerProperty, argument_error from jsonargparse_tests.conftest import ( get_parser_help, skip_if_docstring_parser_unavailable, @@ -56,7 +57,7 @@ def test_deprecation_warning(): deprecation_warning(None, message) assert 2 == len(w) assert "only one JsonargparseDeprecationWarning per type is shown" in str(w[0].message) - assert message == str(w[1].message) + assert message == str(w[1].message).strip() class MyEnum(Enum): @@ -216,13 +217,6 @@ def test_env_prefix_none(): assert "env_prefix" in str(w[-1].message) -@skip_if_docstring_parser_unavailable -def test_docstring_parse(): - with catch_warnings(record=True) as w: - import_docstring_parse("test_docstring_parse") - assert "Only use the public API" in str(w[-1].message) - - def test_error_handler_parameter(): with catch_warnings(record=True) as w: parser = ArgumentParser(error_handler=usage_and_exit_error_handler) @@ -430,3 +424,52 @@ def test_ActionPathList(tmp_cwd): ValueError, lambda: parser.add_argument("--op3", action=ActionPathList(mode="fr", rel=".")), ) + + +@skip_if_docstring_parser_unavailable +def test_import_import_docstring_parse(): + from jsonargparse._optionals import import_docstring_parser + + with catch_warnings(record=True) as w: + from jsonargparse.optionals import import_docstring_parse + + if sys.version_info[:2] != (3, 6): + assert "Only use the public API" in str(w[-1].message) + assert import_docstring_parse is import_docstring_parser + + +def test_import_from_deprecated(): + import jsonargparse.deprecated as deprecated + + with catch_warnings(record=True) as w: + func = deprecated.set_url_support + + if sys.version_info[:2] != (3, 6): + assert "Only use the public API" in str(w[-1].message) + assert func is set_url_support + + +@pytest.mark.parametrize( + ["module", "attr"], + [ + ("actions", "ActionYesNo"), + ("cli", "CLI"), + ("core", "ArgumentParser"), + ("formatters", "DefaultHelpFormatter"), + ("jsonnet", "ActionJsonnet"), + ("jsonschema", "ActionJsonSchema"), + ("link_arguments", "ArgumentLinking"), + ("loaders_dumpers", "set_loader"), + ("namespace", "Namespace"), + ("signatures", "compose_dataclasses"), + ("typehints", "lazy_instance"), + ("util", "Path"), + ("parameter_resolvers", "ParamData"), + ], +) +def test_import_from_module(module, attr): + module = import_module(f"jsonargparse.{module}") + with catch_warnings(record=True) as w: + getattr(module, attr) + if sys.version_info[:2] != (3, 6): + assert "Only use the public API" in str(w[-1].message) diff --git a/jsonargparse_tests/test_jsonnet.py b/jsonargparse_tests/test_jsonnet.py index ab29e634..59c86e5d 100644 --- a/jsonargparse_tests/test_jsonnet.py +++ b/jsonargparse_tests/test_jsonnet.py @@ -14,7 +14,7 @@ ArgumentParser, strip_meta, ) -from jsonargparse.optionals import jsonnet_support +from jsonargparse._optionals import jsonnet_support from jsonargparse_tests.conftest import get_parser_help, skip_if_jsonschema_unavailable diff --git a/jsonargparse_tests/test_loaders_dumpers.py b/jsonargparse_tests/test_loaders_dumpers.py index 36c009aa..24f42faa 100644 --- a/jsonargparse_tests/test_loaders_dumpers.py +++ b/jsonargparse_tests/test_loaders_dumpers.py @@ -7,8 +7,8 @@ from jsonargparse import ActionConfigFile, ArgumentParser, set_dumper, set_loader from jsonargparse._common import parser_context -from jsonargparse.loaders_dumpers import load_value, loaders, yaml_dump -from jsonargparse.optionals import omegaconf_support +from jsonargparse._loaders_dumpers import load_value, loaders, yaml_dump +from jsonargparse._optionals import omegaconf_support def test_set_dumper_custom_yaml(parser): @@ -17,7 +17,7 @@ def test_set_dumper_custom_yaml(parser): def custom_yaml_dump(data) -> str: return yaml.safe_dump(data, default_flow_style=True) - with patch.dict("jsonargparse.loaders_dumpers.dumpers"): + with patch.dict("jsonargparse._loaders_dumpers.dumpers"): set_dumper("yaml_custom", custom_yaml_dump) cfg = parser.parse_args(["--list=[1,2,3]"]) dump = parser.dump(cfg, format="yaml_custom") @@ -89,7 +89,7 @@ def test_set_loader_parser_mode_subparsers(parser, subparser): subcommands = parser.add_subcommands() subcommands.add_subcommand("sub", subparser) - with patch.dict("jsonargparse.loaders_dumpers.loaders"): + with patch.dict("jsonargparse._loaders_dumpers.loaders"): set_loader("custom", yaml.safe_load) parser.parser_mode = "custom" assert "custom" == parser.parser_mode diff --git a/jsonargparse_tests/test_namespace.py b/jsonargparse_tests/test_namespace.py index 3efd7fba..49880bf9 100644 --- a/jsonargparse_tests/test_namespace.py +++ b/jsonargparse_tests/test_namespace.py @@ -4,7 +4,7 @@ import pytest from jsonargparse import Namespace, dict_to_namespace, namespace_to_dict -from jsonargparse.namespace import meta_keys +from jsonargparse._namespace import meta_keys skip_if_no_setattr_insertion_order = pytest.mark.skipif( platform.python_implementation() != "CPython", diff --git a/jsonargparse_tests/test_optionals.py b/jsonargparse_tests/test_optionals.py index d92f4e20..b742639a 100644 --- a/jsonargparse_tests/test_optionals.py +++ b/jsonargparse_tests/test_optionals.py @@ -1,7 +1,7 @@ import pytest from jsonargparse import get_config_read_mode, set_config_read_mode -from jsonargparse.optionals import ( +from jsonargparse._optionals import ( argcomplete_support, docstring_parser_support, fsspec_support, diff --git a/jsonargparse_tests/test_parameter_resolvers.py b/jsonargparse_tests/test_parameter_resolvers.py index 585fa1b6..1e601a82 100644 --- a/jsonargparse_tests/test_parameter_resolvers.py +++ b/jsonargparse_tests/test_parameter_resolvers.py @@ -10,9 +10,9 @@ import pytest from jsonargparse import Namespace, class_from_function -from jsonargparse.optionals import docstring_parser_support -from jsonargparse.parameter_resolvers import get_signature_parameters as get_params -from jsonargparse.parameter_resolvers import is_lambda +from jsonargparse._optionals import docstring_parser_support +from jsonargparse._parameter_resolvers import get_signature_parameters as get_params +from jsonargparse._parameter_resolvers import is_lambda from jsonargparse_tests.conftest import capture_logs diff --git a/jsonargparse_tests/test_signatures.py b/jsonargparse_tests/test_signatures.py index cd887a90..bca27022 100644 --- a/jsonargparse_tests/test_signatures.py +++ b/jsonargparse_tests/test_signatures.py @@ -12,8 +12,8 @@ lazy_instance, strip_meta, ) -from jsonargparse.actions import _find_action -from jsonargparse.optionals import docstring_parser_support +from jsonargparse._actions import _find_action +from jsonargparse._optionals import docstring_parser_support from jsonargparse_tests.conftest import ( capture_logs, get_parse_args_stdout, diff --git a/jsonargparse_tests/test_stubs_resolver.py b/jsonargparse_tests/test_stubs_resolver.py index 30fbe950..ea4b5f4b 100644 --- a/jsonargparse_tests/test_stubs_resolver.py +++ b/jsonargparse_tests/test_stubs_resolver.py @@ -14,8 +14,8 @@ import pytest import yaml +from jsonargparse._parameter_resolvers import get_signature_parameters as get_params from jsonargparse._stubs_resolver import get_mro_method_parent, get_stubs_resolver -from jsonargparse.parameter_resolvers import get_signature_parameters as get_params from jsonargparse_tests.conftest import ( capture_logs, get_parser_help, @@ -33,7 +33,7 @@ def skip_if_typeshed_client_unavailable(): @contextmanager def mock_typeshed_client_unavailable(): - with patch("jsonargparse.parameter_resolvers.add_stub_types"): + with patch("jsonargparse._parameter_resolvers.add_stub_types"): yield diff --git a/jsonargparse_tests/test_typehints.py b/jsonargparse_tests/test_typehints.py index 7b2f667e..fbdb5004 100644 --- a/jsonargparse_tests/test_typehints.py +++ b/jsonargparse_tests/test_typehints.py @@ -25,12 +25,13 @@ import yaml from jsonargparse import ActionConfigFile, ArgumentError, Namespace, lazy_instance -from jsonargparse.typehints import ( +from jsonargparse._typehints import ( ActionTypeHint, Literal, get_all_subclass_paths, is_optional, ) +from jsonargparse._util import get_import_path from jsonargparse.typing import ( NotEmptyStr, Path_fc, @@ -38,7 +39,6 @@ PositiveFloat, PositiveInt, ) -from jsonargparse.util import get_import_path from jsonargparse_tests.conftest import ( capture_logs, get_parse_args_stdout, @@ -842,7 +842,7 @@ def mocked_get_import_path(cls): raise ImportError("Failed to import ImportClass") return get_import_path(cls) - with mock.patch("jsonargparse.typehints.get_import_path", mocked_get_import_path): + with mock.patch("jsonargparse._typehints.get_import_path", mocked_get_import_path): with catch_warnings(record=True) as w: subclass_paths = get_all_subclass_paths(ImportClass) assert "Failed to import ImportClass" in str(w[0].message) diff --git a/jsonargparse_tests/test_util.py b/jsonargparse_tests/test_util.py index b7f9198a..d129459b 100644 --- a/jsonargparse_tests/test_util.py +++ b/jsonargparse_tests/test_util.py @@ -19,13 +19,13 @@ class_from_function, null_logger, ) -from jsonargparse.optionals import ( +from jsonargparse._optionals import ( docstring_parser_support, fsspec_support, reconplogger_support, url_support, ) -from jsonargparse.util import ( +from jsonargparse._util import ( CaptureParserException, current_path_dir, get_import_path, @@ -521,7 +521,7 @@ def unresolvable_import(): pass -@patch.dict("jsonargparse.util.unresolvable_import_paths") +@patch.dict("jsonargparse._util.unresolvable_import_paths") def test_register_unresolvable_import_paths(): unresolvable_import.__module__ = None pytest.raises(ValueError, lambda: get_import_path(unresolvable_import))