Refactor loader into subdirectory

salt/loader/__init__.py

@@ -26,7 +26,7 @@ from zipimport import zipimporter
 import salt.config
 import salt.defaults.events
 import salt.defaults.exitcodes
-import salt.loader_context
+import salt.loader.context
 import salt.syspaths
 import salt.utils.args
 import salt.utils.context
@@ -1316,14 +1316,14 @@ class LazyLoader(salt.utils.lazy.LazyDict):
         self.inject_globals = {}
         self.pack = {} if pack is None else pack
         for i in self.pack:
-            if isinstance(self.pack[i], salt.loader_context.NamedLoaderContext):
+            if isinstance(self.pack[i], salt.loader.context.NamedLoaderContext):
                 self.pack[i] = self.pack[i].value()
         if opts is None:
             opts = {}
         opts = copy.deepcopy(opts)
         for i in ["pillar", "grains"]:
             if i in opts and isinstance(
-                opts[i], salt.loader_context.NamedLoaderContext
+                opts[i], salt.loader.context.NamedLoaderContext
             ):
                 opts[i] = opts[i].value()
         threadsafety = not opts.get("multiprocessing")
@@ -1637,7 +1637,7 @@ class LazyLoader(salt.utils.lazy.LazyDict):
         """
         if "__grains__" not in self.pack:
             grains = opts.get("grains", {})
-            if isinstance(grains, salt.loader_context.NamedLoaderContext):
+            if isinstance(grains, salt.loader.context.NamedLoaderContext):
                 grains = grains.value()
             self.context_dict["grains"] = grains
             self.pack["__grains__"] = salt.utils.context.NamespacedDictWrapper(
@@ -1646,7 +1646,7 @@ class LazyLoader(salt.utils.lazy.LazyDict):
 
         if "__pillar__" not in self.pack:
             pillar = opts.get("pillar", {})
-            if isinstance(pillar, salt.loader_context.NamedLoaderContext):
+            if isinstance(pillar, salt.loader.context.NamedLoaderContext):
                 pillar = pillar.value()
             self.context_dict["pillar"] = pillar
             self.pack["__pillar__"] = salt.utils.context.NamespacedDictWrapper(
@@ -1889,16 +1889,16 @@ class LazyLoader(salt.utils.lazy.LazyDict):
             sys.path.remove(fpath_dirname)
             self.__clean_sys_path()
 
-        loader_context = salt.loader_context.LoaderContext()
+        loader_context = salt.loader.context.LoaderContext()
         if hasattr(mod, "__salt_loader__"):
-            if not isinstance(mod.__salt_loader__, salt.loader_context.LoaderContext):
+            if not isinstance(mod.__salt_loader__, salt.loader.context.LoaderContext):
                 log.warning("Override  __salt_loader__: %s", mod)
                 mod.__salt_loader__ = loader_context
         else:
             mod.__salt_loader__ = loader_context
 
         if hasattr(mod, "__opts__"):
-            if not isinstance(mod.__opts__, salt.loader_context.NamedLoaderContext):
+            if not isinstance(mod.__opts__, salt.loader.context.NamedLoaderContext):
                 if not hasattr(mod, "__orig_opts__"):
                     mod.__orig_opts__ = copy.deepcopy(mod.__opts__)
                 mod.__opts__ = copy.deepcopy(mod.__orig_opts__)
@@ -2279,17 +2279,17 @@ class LazyLoader(salt.utils.lazy.LazyDict):
         """
         self.parent_loader = None
         try:
-            current_loader = salt.loader_context.loader_ctxvar.get()
+            current_loader = salt.loader.context.loader_ctxvar.get()
         except LookupError:
             current_loader = None
         if current_loader is not self:
             self.parent_loader = current_loader
-        token = salt.loader_context.loader_ctxvar.set(self)
+        token = salt.loader.context.loader_ctxvar.set(self)
         try:
             return _func_or_method(*args, **kwargs)
         finally:
             self.parent_loader = None
-            salt.loader_context.loader_ctxvar.reset(token)
+            salt.loader.context.loader_ctxvar.reset(token)
 
     def run_in_thread(self, _func_or_method, *args, **kwargs):
         """

salt/payload.py

@@ -12,7 +12,7 @@ import gc
 # import sys  # Use if sys is commented out below
 import logging
 
-import salt.loader_context
+import salt.loader.context
 import salt.log
 import salt.transport.frame
 import salt.utils.immutabletypes as immutabletypes

salt/renderers/jinja.py

@@ -10,7 +10,7 @@ from io import StringIO
 
 import salt.utils.templates
 from salt.exceptions import SaltRenderError
-from salt.loader_context import NamedLoaderContext
+from salt.loader.context import NamedLoaderContext
 
 log = logging.getLogger(__name__)
 

salt/utils/boto3mod.py

@@ -30,7 +30,7 @@ import logging
 import sys
 from functools import partial
 
-import salt.loader_context
+import salt.loader.context
 import salt.utils.stringutils
 import salt.utils.versions
 from salt.exceptions import SaltInvocationError
@@ -55,7 +55,7 @@ except ImportError:
 log = logging.getLogger(__name__)
 
 __virtualname__ = "boto3"
-__salt_loader__ = salt.loader_context.LoaderContext()
+__salt_loader__ = salt.loader.context.LoaderContext()
 __context__ = __salt_loader__.named_context("__context__", {})
 
 

salt/utils/botomod.py

@@ -30,7 +30,7 @@ import logging
 import sys
 from functools import partial
 
-import salt.loader_context
+import salt.loader.context
 import salt.utils.stringutils
 import salt.utils.versions
 from salt.exceptions import SaltInvocationError
@@ -54,7 +54,7 @@ log = logging.getLogger(__name__)
 
 __salt__ = None
 __virtualname__ = "boto"
-__salt_loader__ = salt.loader_context.LoaderContext()
+__salt_loader__ = salt.loader.context.LoaderContext()
 __context__ = __salt_loader__.named_context("__context__", {})
 
 

salt/utils/systemd.py

@@ -7,7 +7,7 @@ import os
 import re
 import subprocess
 
-import salt.loader_context
+import salt.loader.context
 import salt.utils.stringutils
 from salt.exceptions import SaltInvocationError
 
@@ -28,7 +28,7 @@ def booted(context=None):
     keep the logic below from needing to be run again during the same salt run.
     """
     contextkey = "salt.utils.systemd.booted"
-    if isinstance(context, (dict, salt.loader_context.NamedLoaderContext)):
+    if isinstance(context, (dict, salt.loader.context.NamedLoaderContext)):
         # Can't put this if block on the same line as the above if block,
         # because it willl break the elif below.
         if contextkey in context:
@@ -57,7 +57,7 @@ def version(context=None):
     version.
     """
     contextkey = "salt.utils.systemd.version"
-    if isinstance(context, (dict, salt.loader_context.NamedLoaderContext)):
+    if isinstance(context, (dict, salt.loader.context.NamedLoaderContext)):
         # Can't put this if block on the same line as the above if block,
         # because it will break the elif below.
         if contextkey in context:

salt/utils/templates.py

@@ -25,7 +25,7 @@ import salt.utils.yamlencoding
 from salt import __path__ as saltpath
 from salt.exceptions import CommandExecutionError, SaltInvocationError, SaltRenderError
 from salt.features import features
-from salt.loader_context import NamedLoaderContext
+from salt.loader.context import NamedLoaderContext
 from salt.utils.decorators.jinja import JinjaFilter, JinjaGlobal, JinjaTest
 from salt.utils.odict import OrderedDict
 from salt.utils.versions import LooseVersion

tests/filename_map.yml

@@ -186,7 +186,7 @@ salt/(client/ssh/.+|cli/ssh\.py):
 salt/config/*:
   - unit.test_config
 
-salt/loader.py:
+salt/loader/*:
   - integration.loader.test_ext_grains
   - integration.loader.test_ext_modules
   - pytests.functional.test_loader

tests/pytests/unit/modules/test_state.py

@@ -2,7 +2,7 @@
     Unit tests for the salt.modules.state module
 """
 
-import salt.loader_context
+import salt.loader.context
 import salt.modules.state
 from tests.support.mock import patch
 
@@ -11,7 +11,7 @@ def test_get_initial_pillar():
     """
     _get_initial_pillar returns pillar data not named context
     """
-    ctx = salt.loader_context.LoaderContext()
+    ctx = salt.loader.context.LoaderContext()
     pillar_data = {"foo": "bar"}
     named_ctx = ctx.named_context("__pillar__", pillar_data)
     opts = {"__cli": "salt-call", "pillarenv": "base"}

tests/pytests/unit/test_loader.py

@@ -7,7 +7,7 @@ import sys
 
 import pytest
 import salt.loader
-import salt.loader_context
+import salt.loader.context
 import salt.utils.files
 from tests.support.helpers import dedent
 
@@ -92,18 +92,18 @@ def test_loaders_create_named_loader_contexts(loader_dir):
     assert isinstance(func, salt.loader.LoadedFunc)
     module_name = func.func.__module__
     module = sys.modules[module_name]
-    assert isinstance(module.__context__, salt.loader_context.NamedLoaderContext)
+    assert isinstance(module.__context__, salt.loader.context.NamedLoaderContext)
 
 
 def test_loaders_convert_context_to_values(loader_dir):
     """
     LazyLoaders convert NamedLoaderContexts to values when instantiated.
     """
-    loader_context = salt.loader_context.LoaderContext()
+    loader_context = salt.loader.context.LoaderContext()
     grains_default = {
         "os": "linux",
     }
-    grains = salt.loader_context.NamedLoaderContext(
+    grains = salt.loader.context.NamedLoaderContext(
         "grains", loader_context, grains_default
     )
     opts = {

tests/pytests/unit/test_loader_context.py

@@ -1,32 +1,32 @@
 """
-Tests for salt.loader_context
+Tests for salt.loader.context
 """
 import copy
 
 import salt.loader
-import salt.loader_context
+import salt.loader.context
 
 
 def test_named_loader_context():
-    loader_context = salt.loader_context.LoaderContext()
-    named_context = salt.loader_context.NamedLoaderContext("__test__", loader_context)
+    loader_context = salt.loader.context.LoaderContext()
+    named_context = salt.loader.context.NamedLoaderContext("__test__", loader_context)
     test_dunder = {"foo": "bar"}
     lazy_loader = salt.loader.LazyLoader(["/foo"], pack={"__test__": test_dunder})
     assert named_context.loader() is None
-    token = salt.loader_context.loader_ctxvar.set(lazy_loader)
+    token = salt.loader.context.loader_ctxvar.set(lazy_loader)
     try:
         assert named_context.loader() == lazy_loader
         # The loader's value is the same object as test_dunder
         assert named_context.value() is test_dunder
         assert named_context["foo"] == "bar"
     finally:
-        salt.loader_context.loader_ctxvar.reset(token)
+        salt.loader.context.loader_ctxvar.reset(token)
 
 
 def test_named_loader_default():
-    loader_context = salt.loader_context.LoaderContext()
+    loader_context = salt.loader.context.LoaderContext()
     default = {"foo": "bar"}
-    named_context = salt.loader_context.NamedLoaderContext(
+    named_context = salt.loader.context.NamedLoaderContext(
         "__test__", loader_context, default=default
     )
     assert named_context.loader() is None
@@ -36,9 +36,9 @@ def test_named_loader_default():
 
 
 def test_named_loader_context_deepcopy():
-    loader_context = salt.loader_context.LoaderContext()
+    loader_context = salt.loader.context.LoaderContext()
     default_data = {"foo": "bar"}
-    named_context = salt.loader_context.NamedLoaderContext(
+    named_context = salt.loader.context.NamedLoaderContext(
         "__test__", loader_context, default_data
     )
     coppied = copy.deepcopy(named_context)

tests/unit/modules/test_boto_apigateway.py

@@ -4,7 +4,7 @@ import random
 import string
 
 import salt.loader
-import salt.loader_context
+import salt.loader.context
 import salt.modules.boto_apigateway as boto_apigateway
 from salt.utils.versions import LooseVersion
 from tests.support.mixins import LoaderModuleMockMixin
@@ -711,7 +711,7 @@ class BotoApiGatewayTestCase(BotoApiGatewayTestCaseBase, BotoApiGatewayTestCaseM
         """
         tests that we properly handle errors when create an api key fails.
         """
-        with salt.loader_context.loader_context(self.utils):
+        with salt.loader.context.loader_context(self.utils):
             self.conn.create_api_key.side_effect = ClientError(
                 error_content, "create_api_key"
             )

tests/unit/test_loader.py

@@ -20,7 +20,7 @@ import textwrap
 import pytest
 import salt.config
 import salt.loader
-import salt.loader_context
+import salt.loader.context
 import salt.utils.files
 import salt.utils.stringutils
 from tests.support.case import ModuleCase
@@ -317,7 +317,7 @@ class LazyLoaderVirtualEnabledTest(TestCase):
         self.assertEqual(self.loader._dict, {})
         # get something, and make sure its a func
         func = self.loader["test.ping"]
-        with salt.loader_context.loader_context(self.loader):
+        with salt.loader.context.loader_context(self.loader):
             with patch.dict(func.__globals__["__context__"], {"foo": "bar"}):
                 self.assertEqual(
                     self.loader["test.echo"].__globals__["__context__"]["foo"], "bar"
@@ -327,7 +327,7 @@ class LazyLoaderVirtualEnabledTest(TestCase):
                 )
 
     def test_globals(self):
-        with salt.loader_context.loader_context(self.loader):
+        with salt.loader.context.loader_context(self.loader):
             func_globals = self.loader["test.ping"].__globals__
             self.assertEqual(
                 func_globals["__grains__"].value(), self.opts.get("grains", {})
@@ -354,7 +354,7 @@ class LazyLoaderVirtualEnabledTest(TestCase):
                 self.assertEqual(self.opts[key], val)
 
     def test_pack(self):
-        with salt.loader_context.loader_context(self.loader):
+        with salt.loader.context.loader_context(self.loader):
             self.loader.pack["__foo__"] = "bar"
             func_globals = self.loader["test.ping"].__globals__
             self.assertEqual(func_globals["__foo__"].value(), "bar")
@@ -1299,16 +1299,16 @@ class LoaderMultipleGlobalTest(ModuleCase):
 
         self.loader2.pack["__foo__"] = "bar2"
         func2 = self.loader2["test.ping"]
-        token = salt.loader_context.loader_ctxvar.set(self.loader1)
+        token = salt.loader.context.loader_ctxvar.set(self.loader1)
         try:
             assert func1.__globals__["__foo__"].value() == "bar1"
         finally:
-            salt.loader_context.loader_ctxvar.reset(token)
-        token = salt.loader_context.loader_ctxvar.set(self.loader2)
+            salt.loader.context.loader_ctxvar.reset(token)
+        token = salt.loader.context.loader_ctxvar.set(self.loader2)
         try:
             assert func2.__globals__["__foo__"].value() == "bar2"
         finally:
-            salt.loader_context.loader_ctxvar.reset(token)
+            salt.loader.context.loader_ctxvar.reset(token)
 
 
 class LoaderCleanupTest(ModuleCase):