ansible-core 2.18.5rc1__py3-none-any.whl → 2.19.0b2__py3-none-any.whl

ansible/vars/hostvars.py

@@ -17,131 +17,101 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
-from functools import cached_property
+import collections.abc as c
+import typing as t
 
-from ansible import constants as C
-from ansible.template import Templar, AnsibleUndefined
+from ansible.module_utils._internal import _datatag
 
+if t.TYPE_CHECKING:
+    from ansible.inventory.manager import InventoryManager
+    from ansible.parsing.dataloader import DataLoader
+    from ansible._internal._templating._jinja_common import Marker
+    from ansible.vars.manager import VariableManager
 
-__all__ = ['HostVars', 'HostVarsVars']
 
+__all__ = ['HostVars', 'HostVarsVars']
 
-# Note -- this is a Mapping, not a MutableMapping
-class HostVars(Mapping):
-    ''' A special view of vars_cache that adds values from the inventory when needed. '''
 
-    def __init__(self, inventory, variable_manager, loader):
+class HostVars(c.Mapping):
+    """A read-only wrapper to enable on-demand templating of a specific host's variables under that host's variable context."""
+    def __init__(self, inventory: InventoryManager, variable_manager: VariableManager, loader: DataLoader) -> None:
         self._inventory = inventory
         self._loader = loader
         self._variable_manager = variable_manager
-        variable_manager._hostvars = self
 
-    def set_variable_manager(self, variable_manager):
-        self._variable_manager = variable_manager
         variable_manager._hostvars = self
 
-    def set_inventory(self, inventory):
-        self._inventory = inventory
-
-    def _find_host(self, host_name):
-        # does not use inventory.hosts so it can create localhost on demand
-        return self._inventory.get_host(host_name)
-
-    def raw_get(self, host_name):
-        '''
+    def raw_get(self, host_name: str) -> dict[str, t.Any] | Marker:
+        """
         Similar to __getitem__, however the returned data is not run through
         the templating engine to expand variables in the hostvars.
-        '''
-        host = self._find_host(host_name)
+        """
+        # does not use inventory.hosts, so it can create localhost on demand
+        host = self._inventory.get_host(host_name)
+
         if host is None:
-            return AnsibleUndefined(name="hostvars['%s']" % host_name)
+            from ansible._internal._templating import _jinja_bits
 
-        return self._variable_manager.get_vars(host=host, include_hostvars=False)
+            return _jinja_bits._undef(f"hostvars[{host_name!r}]")
 
-    def __setstate__(self, state):
-        self.__dict__.update(state)
+        return self._variable_manager.get_vars(host=host, include_hostvars=False)
 
-        # Methods __getstate__ and __setstate__ of VariableManager do not
-        # preserve _loader and _hostvars attributes to improve pickle
-        # performance and memory utilization. Since HostVars holds values
-        # of those attributes already, assign them if needed.
-        if self._variable_manager._loader is None:
-            self._variable_manager._loader = self._loader
+    def __getitem__(self, key: str) -> HostVarsVars | Marker:
+        data = self.raw_get(key)
 
-        if self._variable_manager._hostvars is None:
-            self._variable_manager._hostvars = self
+        from ansible._internal._templating import _jinja_bits
 
-    def __getitem__(self, host_name):
-        data = self.raw_get(host_name)
-        if isinstance(data, AnsibleUndefined):
+        if isinstance(data, _jinja_bits.Marker):
             return data
-        return HostVarsVars(data, loader=self._loader)
-
-    def set_host_variable(self, host, varname, value):
-        self._variable_manager.set_host_variable(host, varname, value)
-
-    def set_nonpersistent_facts(self, host, facts):
-        self._variable_manager.set_nonpersistent_facts(host, facts)
-
-    def set_host_facts(self, host, facts):
-        self._variable_manager.set_host_facts(host, facts)
 
-    def __contains__(self, host_name):
-        # does not use inventory.hosts so it can create localhost on demand
-        return self._find_host(host_name) is not None
+        return HostVarsVars(data, loader=self._loader, host=key)
 
-    def __iter__(self):
-        # include implicit localhost only if it has variables set
-        yield from self._inventory.hosts | {'localhost': self._inventory.localhost} if self._inventory.localhost else {}
+    def __contains__(self, item: object) -> bool:
+        # does not use inventory.hosts, so it can create localhost on demand
+        return self._inventory.get_host(item) is not None
 
-    def __len__(self):
-        # include implicit localhost only if it has variables set
-        return len(self._inventory.hosts) + (1 if self._inventory.localhost else 0)
+    def __iter__(self) -> t.Iterator[str]:
+        yield from self._inventory.hosts
 
-    def __repr__(self):
-        out = {}
-        for host in self._inventory.hosts:
-            out[host] = self.get(host)
-        return repr(out)
+    def __len__(self) -> int:
+        return len(self._inventory.hosts)
 
-    def __deepcopy__(self, memo):
-        # We do not need to deepcopy because HostVars is immutable,
-        # however we have to implement the method so we can deepcopy
-        # variables' dicts that contain HostVars.
+    def __deepcopy__(self, memo: t.Any) -> HostVars:
+        # this object may be stored in a var dict that is itself deep copied, but since the underlying data
+        # is supposed to be immutable, we don't need to actually copy the data
         return self
 
 
-class HostVarsVars(Mapping):
+class HostVarsVars(c.Mapping):
+    """A read-only view of a specific host's vars that will template on access under that host's variable context."""
+
+    def __init__(self, variables: dict[str, t.Any], loader: DataLoader | None, host: str) -> None:
+        from ansible._internal._templating import _engine
 
-    def __init__(self, variables, loader):
         self._vars = variables
-        self._loader = loader
+        self._templar = _engine.TemplateEngine(variables=variables, loader=loader)
+        self._host = host
 
-    @cached_property
-    def _templar(self):
-        # NOTE: this only has access to the host's own vars,
-        # so templates that depend on vars in other scopes will not work.
-        return Templar(variables=self._vars, loader=self._loader)
+    def __getitem__(self, key: str) -> t.Any:
+        return self._templar.template(self._vars[key])
 
-    def __getitem__(self, var):
-        return self._templar.template(self._vars[var], fail_on_undefined=False, static_vars=C.INTERNAL_STATIC_VARS)
+    def __contains__(self, item: object) -> bool:
+        return item in self._vars
 
-    def __contains__(self, var):
-        return (var in self._vars)
+    def __iter__(self) -> t.Iterator[str]:
+        yield from self._vars
 
-    def __iter__(self):
-        yield from self._vars.keys()
+    def __len__(self) -> int:
+        return len(self._vars)
 
-    def __len__(self):
-        return len(self._vars.keys())
+    def __repr__(self) -> str:
+        return f'HostVarsVars({self._host=!r}, ...)'
+
+    def __deepcopy__(self, memo: t.Any) -> HostVarsVars:
+        # this may be stored in a var dict that is itself deep copied, but since the underlying data
+        # is supposed to be immutable, we don't need to actually copy the data
+        return self
 
-    def __repr__(self):
-        return repr(self._templar.template(self._vars, fail_on_undefined=False, static_vars=C.INTERNAL_STATIC_VARS))
 
-    def __getstate__(self):
-        ''' override serialization here to avoid
-            pickle issues with templar and Jinja native'''
-        state = self.__dict__.copy()
-        state.pop('_templar', None)
-        return state
+# DTFIX-RELEASE: is there a better way to add this to the ignorable types in the module_utils code
+_datatag._untaggable_types.update({HostVars, HostVarsVars})