Fixed optional packages being imported even though not used.

Author: mauvilsa

CHANGELOG.rst

@@ -21,6 +21,7 @@ Fixed
 ^^^^^
 - Failure to parse when subcommand has no options `#158
   <https://github.com/omni-us/jsonargparse/issues/158>`__.
+- Optional packages being imported even though not used.
 
 
 v4.13.2 (2022-08-31)

jsonargparse/core.py

@@ -9,14 +9,13 @@
 import sys
 from copy import deepcopy
 from typing import Any, Callable, Dict, List, NoReturn, Optional, Sequence, Set, Tuple, Type, Union
-from unittest.mock import patch
 
 from .formatters import DefaultHelpFormatter, empty_help, formatter_context, get_env_var
 from .jsonnet import ActionJsonnet
 from .jsonschema import ActionJsonSchema
 from .link_arguments import ActionLink, ArgumentLinking
 from .loaders_dumpers import check_valid_dump_format, dump_using_format, get_loader_exceptions, loaders, load_value, load_value_context, yaml_load
-from .namespace import dict_to_namespace, is_meta_key, Namespace, split_key, split_key_leaf, strip_meta
+from .namespace import dict_to_namespace, is_meta_key, Namespace, patch_namespace, split_key, split_key_leaf, strip_meta
 from .signatures import is_pure_dataclass, SignatureArguments
 from .typehints import ActionTypeHint, is_subclass_spec
 from .typing import is_final_class
@@ -233,7 +232,7 @@ def parse_known_args(self, args=None, namespace=None):
         namespace = argcomplete_namespace(caller, self, namespace)
 
         try:
-            with patch('argparse.Namespace', Namespace), lenient_check_context(caller), ActionTypeHint.subclass_arg_context(self), load_value_context(self.parser_mode):
+            with patch_namespace(), lenient_check_context(caller), ActionTypeHint.subclass_arg_context(self), load_value_context(self.parser_mode):
                 namespace, args = self._parse_known_args(args, namespace)
         except (argparse.ArgumentError, ParserError) as ex:
             self.error(str(ex), ex)
@@ -1409,6 +1408,10 @@ def parser_mode(self) -> str:
 
     @parser_mode.setter
     def parser_mode(self, parser_mode: str):
+        if parser_mode not in loaders and parser_mode == 'omegaconf' and omegaconf_support:
+            from .loaders_dumpers import set_loader
+            from .optionals import get_omegaconf_loader
+            set_loader('omegaconf', get_omegaconf_loader())
         if parser_mode not in loaders:
             raise ValueError(f'The only accepted values for parser_mode are {set(loaders.keys())}.')
         if parser_mode == 'jsonnet':
@@ -1439,12 +1442,6 @@ def dump_header(self, dump_header: Optional[List[str]]):
         self._dump_header = dump_header
 
 
-if omegaconf_support:
-    from .loaders_dumpers import set_loader
-    from .optionals import get_omegaconf_loader
-    set_loader('omegaconf', get_omegaconf_loader())
-
-
 from .deprecated import parse_as_dict_patch, instantiate_subclasses_patch
 instantiate_subclasses_patch()
 if 'JSONARGPARSE_SKIP_DEPRECATION_PATCH' not in os.environ:

jsonargparse/namespace.py

@@ -1,6 +1,7 @@
 """Classes and functions related to namespace objects."""
 
-from argparse import Namespace as ArgparseNamespace
+import argparse
+from contextlib import contextmanager
 from copy import deepcopy
 from typing import Any, Callable, Dict, Iterator, List, Optional, overload, Tuple, Union
 
@@ -67,6 +68,16 @@ def strip_meta(cfg):
     return cfg
 
 
+@contextmanager
+def patch_namespace():
+    namespace_class = argparse.Namespace
+    argparse.Namespace = Namespace
+    try:
+        yield
+    finally:
+        argparse.Namespace = namespace_class
+
+
 def namespace_to_dict(namespace: 'Namespace') -> Dict[str, Any]:
     """Returns a deepcopy of a nested namespace converted into a nested dictionary."""
     return namespace.clone().as_dict()
@@ -87,14 +98,14 @@ def expand_dict(cfg):
     return expand_dict(cfg_dict)
 
 
-class Namespace(ArgparseNamespace):
+class Namespace(argparse.Namespace):
     """Extension of argparse's Namespace to support nesting and subscript access."""
 
     def __init__(self, *args, **kwargs):
         if len(args) == 0:
             super().__init__(**kwargs)
         else:
-            if len(kwargs) != 0 or len(args) != 1 or not isinstance(args[0], (ArgparseNamespace, dict)):
+            if len(kwargs) != 0 or len(args) != 1 or not isinstance(args[0], (argparse.Namespace, dict)):
                 raise ValueError('Expected a single positional parameter of type Namespace or dict.')
             for key, val in (args[0].items() if type(args[0]) is dict else vars(args[0]).items()):
                 self[key] = val
@@ -211,9 +222,9 @@ def as_dict(self) -> Dict[str, Any]:
             dic[key] = val
         return dic
 
-    def as_flat(self) -> ArgparseNamespace:
+    def as_flat(self) -> argparse.Namespace:
         """Converts the nested namespaces into a single argparse flat namespace."""
-        flat = ArgparseNamespace()
+        flat = argparse.Namespace()
         for key, val in self.items():
             setattr(flat, key, val)
         return flat

jsonargparse/optionals.py

@@ -50,14 +50,9 @@ class UndefinedException(Exception):
     pass
 
 
-if jsonschema_support:
-    from jsonschema.exceptions import ValidationError as jsonschemaValidationError
-else:
-    jsonschemaValidationError = UndefinedException
-
-
 def get_jsonschema_exceptions():
-    return (jsonschemaValidationError,)
+    from jsonschema.exceptions import ValidationError
+    return (ValidationError,)
 
 
 @contextmanager
@@ -173,15 +168,15 @@ def parse_docs(component, parent, logger):
     return docs
 
 
-files_completer = None
-if argcomplete_support:
+def get_files_completer():
     from argcomplete.completers import FilesCompleter
-    files_completer = FilesCompleter()
+    return FilesCompleter()
 
 
 class FilesCompleterMethod:
     """Completer method for Action classes that should complete files."""
     def completer(self, prefix, **kwargs):
+        files_completer = get_files_completer()
         return sorted(files_completer(prefix, **kwargs))
 
 

jsonargparse/typehints.py

@@ -33,11 +33,11 @@
 
 from .actions import _ActionHelpClassPath, _find_action, _find_parent_action, _is_action_value_list
 from .loaders_dumpers import get_loader_exceptions, load_value
-from .namespace import Namespace, split_key_root
+from .namespace import Namespace
 from .typing import is_final_class, registered_types
 from .optionals import (
     argcomplete_warn_redraw_prompt,
-    files_completer,
+    get_files_completer,
     typing_extensions_import,
 )
 from .util import (
@@ -432,6 +432,7 @@ def completer(self, prefix, **kwargs):
             enum = self._typehint.__args__[0]
             return list(enum.__members__.keys())+['null']
         elif is_optional(self._typehint, Path):
+            files_completer = get_files_completer()
             return ['null'] + sorted(files_completer(prefix, **kwargs))
         elif chr(int(os.environ['COMP_TYPE'])) == '?':
             try:

jsonargparse_tests/test_core.py

@@ -5,6 +5,7 @@
 import pickle
 import sys
 import unittest
+import unittest.mock
 import warnings
 import yaml
 from io import StringIO

jsonargparse_tests/test_namespace.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 
+import argparse
 import unittest
-from jsonargparse.namespace import ArgparseNamespace, Namespace, namespace_to_dict, dict_to_namespace
+from jsonargparse.namespace import Namespace, namespace_to_dict, dict_to_namespace
 from jsonargparse_tests.base import is_cpython
 
 
@@ -148,7 +149,7 @@ def test_as_flat(self):
         ns['w'] = 1
         ns['x.y.z'] = 2
         flat = ns.as_flat()
-        self.assertIsInstance(flat, ArgparseNamespace)
+        self.assertIsInstance(flat, argparse.Namespace)
         self.assertEqual(vars(flat), {'w': 1, 'x.y.z': 2})
 
     def test_clone(self):
@@ -172,7 +173,7 @@ def test_update_invalid(self):
         self.assertRaises(KeyError, lambda: ns.update(123))
 
     def test_init_from_argparse_flat_namespace(self):
-        argparse_ns = ArgparseNamespace()
+        argparse_ns = argparse.Namespace()
         setattr(argparse_ns, 'w', 0)
         setattr(argparse_ns, 'x.y.a', 1)
         setattr(argparse_ns, 'x.y.b', 2)
@@ -182,7 +183,7 @@ def test_init_from_argparse_flat_namespace(self):
 
     def test_init_invalid(self):
         self.assertRaises(ValueError, lambda: Namespace(1))
-        self.assertRaises(ValueError, lambda: Namespace(ArgparseNamespace(), x=1))
+        self.assertRaises(ValueError, lambda: Namespace(argparse.Namespace(), x=1))
 
     def test_namespace_to_dict(self):
         ns = Namespace()