Refactoring and import tests

Author: sokolegg

Makefile

@@ -6,6 +6,7 @@ lint:
 	flake8 piper
 
 unit:
+	pytest -vs tests/import_tests.py
 	pytest -vs tests/base_test.py
 	pytest -vs tests/envs_test.py::TestCompose
 	pytest -vs tests/envs_test.py::TestVenv

piper/__init__.py

@@ -1,10 +1,11 @@
 from piper.configurations import get_configuration
-from piper.imports import activate_safe_import
+from piper.imports import _set_import_functions
 
 configuration = get_configuration()
+
 if configuration.ignore_import_errors:
     """
-    Piper activates safe import if configured True.
+    Piper activates safe import globally for piper work if configured True.
     This ignores any import errors for safe imports in piper.base.executors
     """
-    activate_safe_import()
+    _set_import_functions(ignore=True)

piper/configurations.py

@@ -13,6 +13,7 @@ class Configuration:
 
     env: str = 'compose'
     ignore_import_errors: bool = True
+    safe_import_activated: bool = False
 
     # start time and counter
     wait_on_iter = 0.5

piper/imports.py

@@ -28,29 +28,52 @@ def __getattr__(self, name):
     __all__ = []
 
 
+def _piper_was_touched_in_frame(frame_before=1):
+    call_function_frame = inspect.currentframe().f_back
+    frame = call_function_frame
+    for i in range(frame_before):
+        frame = frame.f_back
+
+    result = False
+    f_locals = frame.f_locals
+    f_globals = frame.f_globals
+    all_variables = f_locals | f_globals
+
+    if all_variables.values():
+        all_variables = [v for v in all_variables.values() if v is not None]
+        if len(all_variables) > 0:
+            variables_have_piper_package = any("piper" in v.__package__ \
+                    for v in all_variables if hasattr(v, "__package__") and type(v.__package__) == str)
+            variables_have_piper_module = any("piper" in v.__module__ \
+                    for v in all_variables if hasattr(v, "__module__") and type(v.__module__) == str)
+            result = variables_have_piper_module | variables_have_piper_package
+
+    return result
+
+
+def _from_piper_file_but_not_piper(name: str, globals={}):
+    is_import_from_piper_source_code = "__file__" in globals and "piper/" in globals["__file__"]
+    not_piper_import = not ("piper" in name)
+    result = is_import_from_piper_source_code and not_piper_import
+
+    return result
+
+
 def try_import(name, globals={}, locals={}, fromlist=[], level=0):
     """
     This import replace real Python import with fake import which returns warning only and PiperDummyModule.
     This works for everything under piper/ frameworks files by filename but not for piper import (like piper.base)
     And this also works for every file where you import something from piper firstly !
     """
-    is_piper_imported_from_previous_module = False
-    prev_module_locals = inspect.currentframe().f_back.f_locals
-    prev_module_globals = inspect.currentframe().f_back.f_globals
-    prev_modules = prev_module_locals | prev_module_globals
-
-    if prev_modules.values():
-        prev_modules = [v for v in prev_modules.values() if v is not None and hasattr(v, "__module__")]
-        if len(prev_modules) > 0:
-            is_piper_imported_from_previous_module = \
-                any("piper" in v.__module__ for v in prev_modules if type(v.__module__) == str)
+    if not (configuration.ignore_import_errors or configuration.safe_import_activated):
+        logger.info("Ignore import errors is off in Configuration and deactivated")
+        return real_import(name, globals, locals, fromlist, level)
 
-    is_import_from_piper_source_code = "__file__" in globals and "piper/" in globals["__file__"]
-    not_piper_import = not ("piper" in name)
-    is_from_source_but_not_piper = is_import_from_piper_source_code and not_piper_import
+    piper_was_touched_in_previous_frame = _piper_was_touched_in_frame(frame_before=1)
+    need_to_catch = piper_was_touched_in_previous_frame or _from_piper_file_but_not_piper(name, globals)
 
-    if is_piper_imported_from_previous_module and is_from_source_but_not_piper:
-        logger.info(f"Piper activates safe import for library {name} in piper file {globals['__file__']} ")
+    if need_to_catch:
+        logger.info(f"Piper runs safe import for library {name} in piper file {globals['__file__']} ")
         try:
             return real_import(name, globals, locals, fromlist, level)
         except ImportError as e:
@@ -69,7 +92,7 @@ def try_import(name, globals={}, locals={}, fromlist=[], level=0):
     real_import = builtins.__import__
 
 
-def set_ignore_import_errors(ignore: bool = True):
+def _set_import_functions(ignore: bool = True):
     if ignore:
         builtins.__import__ = try_import
     else:
@@ -89,12 +112,14 @@ def activate_safe_import():
 
     """
     logger.info(f"Piper activates safe import")
-    set_ignore_import_errors(ignore=True)
+    configuration.safe_import_activated = True
+    _set_import_functions(ignore=True)
 
 
 def deactivate_safe_import():
     logger.info(f"Piper deactivates safe import")
-    set_ignore_import_errors(ignore=False)
+    configuration.safe_import_activated = False
+    _set_import_functions(ignore=configuration.ignore_import_errors)
 
 
 class safe_import:

tests/import_tests.py

@@ -0,0 +1,62 @@
+import pytest
+
+
+class TestSafeImport:
+
+    def test_safe_import_after_piper(self):
+        import piper
+        import foo
+        from piper.imports import PiperDummyModule
+        assert isinstance(foo, (PiperDummyModule, ))
+
+    def test_safe_import_before_piper(self):
+        # it doesn't work normally
+        with pytest.raises(ImportError):
+            import foo
+            import piper
+
+    def test_safe_import_after_executors_import(self):
+        from piper.base import executors
+        import foo
+        from piper.imports import PiperDummyModule
+        assert isinstance(foo, (PiperDummyModule, ))
+
+    def test_safe_import_after_base_executor(self):
+        from piper.base.executors import BaseExecutor
+        import foo
+        from piper.imports import PiperDummyModule
+        assert isinstance(foo, (PiperDummyModule, ))
+
+    def test_safe_import_after_piper_as_p(self):
+        import piper as p
+        import foo
+        from piper.imports import PiperDummyModule
+        assert isinstance(foo, (PiperDummyModule,))
+
+    def test_not_ignore_error_by_flag(self):
+        import piper as p
+        p.configurations.Configuration.ignore_import_errors = False
+        with pytest.raises(ImportError):
+            import foo
+
+    def test_safe_import_as_context_when_global_off(self):
+        import piper as p
+        p.configurations.Configuration.ignore_import_errors = False
+        with p.imports.safe_import():
+            import foo
+            from piper.imports import PiperDummyModule
+            assert isinstance(foo, (PiperDummyModule,))
+        # safe import was deactivated
+        with pytest.raises(ImportError):
+            import bar
+
+    def test_safe_import_as_context_when_global_on(self):
+        import piper as p
+        p.configurations.Configuration.ignore_import_errors = True
+        with p.imports.safe_import():
+            import foo
+            from piper.imports import PiperDummyModule
+            assert isinstance(foo, (PiperDummyModule,))
+        # safe import was deactivated but global is on
+        import bar
+        assert isinstance(bar, (PiperDummyModule,))