ansible-core 2.19.0rc1__py3-none-any.whl → 2.19.1rc1__py3-none-any.whl

ansible/_internal/_ansiballz/_builder.py

@@ -6,7 +6,7 @@ import json
 import typing as t
 
 from ansible.module_utils._internal._ansiballz import _extensions
-from ansible.module_utils._internal._ansiballz._extensions import _pydevd, _coverage
+from ansible.module_utils._internal._ansiballz._extensions import _debugpy, _pydevd, _coverage
 from ansible.constants import config
 
 _T = t.TypeVar('_T')
@@ -17,15 +17,18 @@ class ExtensionManager:
 
     def __init__(
         self,
-        debugger: _pydevd.Options | None = None,
+        pydevd: _pydevd.Options | None = None,
+        debugpy: _debugpy.Options | None = None,
         coverage: _coverage.Options | None = None,
     ) -> None:
         options = dict(
-            _pydevd=debugger,
+            _pydevd=pydevd,
+            _debugpy=debugpy,
             _coverage=coverage,
         )
 
-        self._debugger = debugger
+        self._pydevd = pydevd
+        self._debugpy = debugpy
         self._coverage = coverage
         self._extension_names = tuple(name for name, option in options.items() if option)
         self._module_names = tuple(f'{_extensions.__name__}.{name}' for name in self._extension_names)
@@ -35,7 +38,7 @@ class ExtensionManager:
     @property
     def debugger_enabled(self) -> bool:
         """Returns True if the debugger extension is enabled, otherwise False."""
-        return bool(self._debugger)
+        return bool(self._pydevd or self._debugpy)
 
     @property
     def extension_names(self) -> tuple[str, ...]:
@@ -51,10 +54,16 @@ class ExtensionManager:
         """Return the configured extensions and their options."""
         extension_options: dict[str, t.Any] = {}
 
-        if self._debugger:
+        if self._debugpy:
+            extension_options['_debugpy'] = dataclasses.replace(
+                self._debugpy,
+                source_mapping=self._get_source_mapping(self._debugpy.source_mapping),
+            )
+
+        if self._pydevd:
             extension_options['_pydevd'] = dataclasses.replace(
-                self._debugger,
-                source_mapping=self._get_source_mapping(),
+                self._pydevd,
+                source_mapping=self._get_source_mapping(self._pydevd.source_mapping),
             )
 
         if self._coverage:
@@ -64,18 +73,19 @@ class ExtensionManager:
 
         return extensions
 
-    def _get_source_mapping(self) -> dict[str, str]:
+    def _get_source_mapping(self, debugger_mapping: dict[str, str]) -> dict[str, str]:
         """Get the source mapping, adjusting the source root as needed."""
-        if self._debugger.source_mapping:
-            source_mapping = {self._translate_path(key): value for key, value in self.source_mapping.items()}
+        if debugger_mapping:
+            source_mapping = {self._translate_path(key, debugger_mapping): value for key, value in self.source_mapping.items()}
         else:
             source_mapping = self.source_mapping
 
         return source_mapping
 
-    def _translate_path(self, path: str) -> str:
+    @staticmethod
+    def _translate_path(path: str, debugger_mapping: dict[str, str]) -> str:
         """Translate a local path to a foreign path."""
-        for replace, match in self._debugger.source_mapping.items():
+        for replace, match in debugger_mapping.items():
             if path.startswith(match):
                 return replace + path[len(match) :]
 
@@ -85,7 +95,8 @@ class ExtensionManager:
     def create(cls, task_vars: dict[str, object]) -> t.Self:
         """Create an instance using the provided task vars."""
         return cls(
-            debugger=cls._get_options('_ANSIBALLZ_DEBUGGER_CONFIG', _pydevd.Options, task_vars),
+            pydevd=cls._get_options('_ANSIBALLZ_PYDEVD_CONFIG', _pydevd.Options, task_vars),
+            debugpy=cls._get_options('_ANSIBALLZ_DEBUGPY_CONFIG', _debugpy.Options, task_vars),
             coverage=cls._get_options('_ANSIBALLZ_COVERAGE_CONFIG', _coverage.Options, task_vars),
         )
 

ansible/_internal/_templating/_engine.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 import copy
 import dataclasses
 import enum
-import textwrap
 import typing as t
 import collections.abc as c
 import re
@@ -44,7 +43,7 @@ from ._jinja_bits import (
     _finalize_template_result,
     FinalizeMode,
 )
-from ._jinja_common import _TemplateConfig, MarkerError, ExceptionMarker
+from ._jinja_common import _TemplateConfig, MarkerError, ExceptionMarker, JinjaCallContext
 from ._lazy_containers import _AnsibleLazyTemplateMixin
 from ._marker_behaviors import MarkerBehavior, FAIL_ON_UNDEFINED
 from ._transform import _type_transform_mapping
@@ -260,6 +259,7 @@ class TemplateEngine:
             with (
                 TemplateContext(template_value=variable, templar=self, options=options, stop_on_template=stop_on_template) as ctx,
                 DeprecatedAccessAuditContext.when(ctx.is_top_level),
+                JinjaCallContext(accept_lazy_markers=True),  # let default Jinja marker behavior apply, since we're descending into a new template
             ):
                 try:
                     if not value_is_str:
@@ -559,9 +559,11 @@ class TemplateEngine:
 
         bool_result = bool(result)
 
+        result_origin = Origin.get_tag(result) or Origin.UNKNOWN
+
         msg = (
-            f'Conditional result was {textwrap.shorten(str(result), width=40)!r} of type {native_type_name(result)!r}, '
-            f'which evaluates to {bool_result}. Conditionals must have a boolean result.'
+            f'Conditional result ({bool_result}) was derived from value of type {native_type_name(result)!r} at {str(result_origin)!r}. '
+            'Conditionals must have a boolean result.'
         )
 
         if _TemplateConfig.allow_broken_conditionals:

ansible/_internal/_templating/_jinja_bits.py

@@ -811,7 +811,7 @@ class AnsibleEnvironment(SandboxedEnvironment):
             try:
                 value = obj[attribute]
             except (TypeError, LookupError):
-                return self.undefined(obj=obj, name=attribute) if is_safe else self.unsafe_undefined(obj, attribute)
+                value = self.undefined(obj=obj, name=attribute) if is_safe else self.unsafe_undefined(obj, attribute)
 
         AnsibleAccessContext.current().access(value)
 
@@ -891,6 +891,8 @@ def _flatten_nodes(nodes: t.Iterable[t.Any]) -> t.Iterable[t.Any]:
         else:
             if type(node) is TemplateModule:  # pylint: disable=unidiomatic-typecheck
                 yield from _flatten_nodes(node._body_stream)
+            elif node is None:
+                continue  # avoid yielding `None`-valued nodes to avoid literal "None" in stringified template results
             else:
                 yield node
 

ansible/_internal/_templating/_jinja_plugins.py

@@ -115,7 +115,13 @@ class JinjaPluginIntercept(c.MutableMapping):
 
         try:
             with JinjaCallContext(accept_lazy_markers=instance.accept_lazy_markers):
-                return instance.j2_function(*lazify_container_args(args), **lazify_container_kwargs(kwargs))
+                result = instance.j2_function(*lazify_container_args(args), **lazify_container_kwargs(kwargs))
+
+                if instance.plugin_type == 'filter':
+                    # ensure list conversion occurs under the call context
+                    result = _wrap_plugin_output(result)
+
+                return result
         except MarkerError as ex:
             return ex.source
         except Exception as ex:
@@ -156,7 +162,6 @@ class JinjaPluginIntercept(c.MutableMapping):
         @functools.wraps(instance.j2_function)
         def wrapper(*args, **kwargs) -> t.Any:
             result = self._invoke_plugin(instance, *args, **kwargs)
-            result = _wrap_plugin_output(result)
 
             return result
 

ansible/_internal/_templating/_lazy_containers.py

@@ -229,8 +229,6 @@ class _AnsibleLazyTemplateDict(_AnsibleTaggedDict, _AnsibleLazyTemplateMixin):
     __slots__ = _AnsibleLazyTemplateMixin._SLOTS
 
     def __init__(self, contents: t.Iterable | _LazyValueSource, /, **kwargs) -> None:
-        _AnsibleLazyTemplateMixin.__init__(self, contents)
-
         if isinstance(contents, _AnsibleLazyTemplateDict):
             super().__init__(dict.items(contents), **kwargs)
         elif isinstance(contents, _LazyValueSource):
@@ -238,6 +236,8 @@ class _AnsibleLazyTemplateDict(_AnsibleTaggedDict, _AnsibleLazyTemplateMixin):
         else:
             raise UnsupportedConstructionMethodError()
 
+        _AnsibleLazyTemplateMixin.__init__(self, contents)
+
     def get(self, key: t.Any, default: t.Any = None) -> t.Any:
         if (value := super().get(key, _NoKeySentinel)) is _NoKeySentinel:
             return default
@@ -372,8 +372,6 @@ class _AnsibleLazyTemplateList(_AnsibleTaggedList, _AnsibleLazyTemplateMixin):
     __slots__ = _AnsibleLazyTemplateMixin._SLOTS
 
     def __init__(self, contents: t.Iterable | _LazyValueSource, /) -> None:
-        _AnsibleLazyTemplateMixin.__init__(self, contents)
-
         if isinstance(contents, _AnsibleLazyTemplateList):
             super().__init__(list.__iter__(contents))
         elif isinstance(contents, _LazyValueSource):
@@ -381,6 +379,8 @@ class _AnsibleLazyTemplateList(_AnsibleTaggedList, _AnsibleLazyTemplateMixin):
         else:
             raise UnsupportedConstructionMethodError()
 
+        _AnsibleLazyTemplateMixin.__init__(self, contents)
+
     def __getitem__(self, key: t.SupportsIndex | slice, /) -> t.Any:
         if type(key) is slice:  # pylint: disable=unidiomatic-typecheck
             return _AnsibleLazyTemplateList(_LazyValueSource(source=super().__getitem__(key), templar=self._templar, lazy_options=self._lazy_options))
@@ -567,7 +567,7 @@ class _AnsibleLazyAccessTuple(_AnsibleTaggedTuple, _AnsibleLazyTemplateMixin):
 
     def __getitem__(self, key: t.SupportsIndex | slice, /) -> t.Any:
         if type(key) is slice:  # pylint: disable=unidiomatic-typecheck
-            return _AnsibleLazyAccessTuple(super().__getitem__(key))
+            return _AnsibleLazyAccessTuple(_LazyValueSource(source=super().__getitem__(key), templar=self._templar, lazy_options=self._lazy_options))
 
         value = super().__getitem__(key)
 

ansible/config/base.yml

@@ -11,16 +11,26 @@ _ANSIBALLZ_COVERAGE_CONFIG:
   vars:
   - {name: _ansible_ansiballz_coverage_config}
   version_added: '2.19'
-_ANSIBALLZ_DEBUGGER_CONFIG:
-  name: Configure the AnsiballZ remote debugging extension
+_ANSIBALLZ_DEBUGPY_CONFIG:
+  name: Configure the AnsiballZ remote debugging extension for debugpy
   description:
-    - Enables and configures the AnsiballZ remote debugging extension.
+    - Enables and configures the AnsiballZ remote debugging extension for debugpy.
     - This is for internal use only.
   env:
-  - {name: _ANSIBLE_ANSIBALLZ_DEBUGGER_CONFIG}
+  - {name: _ANSIBLE_ANSIBALLZ_DEBUGPY_CONFIG}
   vars:
-  - {name: _ansible_ansiballz_debugger_config}
-  version_added: '2.19'
+  - {name: _ansible_ansiballz_debugpy_config}
+  version_added: '2.20'
+_ANSIBALLZ_PYDEVD_CONFIG:
+  name: Configure the AnsiballZ remote debugging extension for pydevd
+  description:
+    - Enables and configures the AnsiballZ remote debugging extension for pydevd.
+    - This is for internal use only.
+  env:
+  - {name: _ANSIBLE_ANSIBALLZ_PYDEVD_CONFIG}
+  vars:
+  - {name: _ansible_ansiballz_pydevd_config}
+  version_added: '2.20'
 _ANSIBLE_CONNECTION_PATH:
   env:
   - name: _ANSIBLE_CONNECTION_PATH

ansible/config/manager.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import atexit
 import decimal
 import configparser
+import functools
 import os
 import os.path
 import sys
@@ -248,18 +249,6 @@ def get_config_type(cfile):
     return ftype
 
 
-# FIXME: can move to module_utils for use for ini plugins also?
-def get_ini_config_value(p, entry):
-    """ returns the value of last ini entry found """
-    value = None
-    if p is not None:
-        try:
-            value = p.get(entry.get('section', 'defaults'), entry.get('key', ''), raw=True)
-        except Exception:  # FIXME: actually report issues here
-            pass
-    return value
-
-
 def find_ini_config_file(warnings=None):
     """ Load INI Config File order(first found is used): ENV, CWD, HOME, /etc/ansible """
     # FIXME: eventually deprecate ini configs
@@ -345,6 +334,7 @@ class ConfigManager:
     _errors: list[tuple[str, Exception]]
 
     def __init__(self, conf_file=None, defs_file=None):
+        self._get_ini_config_value = functools.cache(self._get_ini_config_value)
 
         self._base_defs = {}
         self._plugins = {}
@@ -460,13 +450,17 @@ class ConfigManager:
         pass
 
     def get_plugin_options(self, plugin_type, name, keys=None, variables=None, direct=None):
+        options, dummy = self.get_plugin_options_and_origins(plugin_type, name, keys=keys, variables=variables, direct=direct)
+        return options
 
+    def get_plugin_options_and_origins(self, plugin_type, name, keys=None, variables=None, direct=None):
         options = {}
+        origins = {}
         defs = self.get_configuration_definitions(plugin_type=plugin_type, name=name)
         for option in defs:
-            options[option] = self.get_config_value(option, plugin_type=plugin_type, plugin_name=name, keys=keys, variables=variables, direct=direct)
-
-        return options
+            options[option], origins[option] = self.get_config_value_and_origin(option, plugin_type=plugin_type, plugin_name=name, keys=keys,
+                                                                                variables=variables, direct=direct)
+        return options, origins
 
     def get_plugin_vars(self, plugin_type, name):
 
@@ -628,6 +622,7 @@ class ConfigManager:
             # env vars are next precedence
             if value is None and defs[config].get('env'):
                 value, origin = self._loop_entries(os.environ, defs[config]['env'])
+                value = _tags.TrustedAsTemplate().tag(value)
                 origin = 'env: %s' % origin
 
             # try config file entries next, if we have one
@@ -642,7 +637,7 @@ class ConfigManager:
                         for entry in defs[config][ftype]:
                             # load from config
                             if ftype == 'ini':
-                                temp_value = get_ini_config_value(self._parsers[cfile], entry)
+                                temp_value = self._get_ini_config_value(cfile, entry.get('section', 'defaults'), entry['key'])
                             elif ftype == 'yaml':
                                 raise AnsibleError('YAML configuration type has not been implemented yet')
                             else:
@@ -724,6 +719,32 @@ class ConfigManager:
 
         self._plugins[plugin_type][name] = defs
 
+    def _get_ini_config_value(self, config_file: str, section: str, option: str) -> t.Any:
+        """
+        Fetch `option` from the specified `section`.
+        Returns `None` if the specified `section` or `option` are not present.
+        Origin and TrustedAsTemplate tags are applied to returned values.
+
+        CAUTION: Although INI sourced configuration values are trusted for templating, that does not automatically mean they will be templated.
+                 It is up to the code consuming configuration values to apply templating if required.
+        """
+        parser = self._parsers[config_file]
+        value = parser.get(section, option, raw=True, fallback=None)
+
+        if value is not None:
+            value = self._apply_tags(value, section, option)
+
+        return value
+
+    def _apply_tags(self, value: str, section: str, option: str) -> t.Any:
+        """Apply origin and trust to the given `value` sourced from the stated `section` and `option`."""
+        description = f'section {section!r} option {option!r}'
+        origin = _tags.Origin(path=self._config_file, description=description)
+        tags = [origin, _tags.TrustedAsTemplate()]
+        value = AnsibleTagHelper.tag(value, tags)
+
+        return value
+
     @staticmethod
     def get_deprecated_msg_from_config(dep_docs, include_removal=False, collection_name=None):
 

ansible/executor/task_executor.py

@@ -712,7 +712,10 @@ class TaskExecutor:
                     condname = 'failed'
 
                     if self._task.failed_when:
-                        result['failed_when_result'] = result['failed'] = self._task._resolve_conditional(self._task.failed_when, vars_copy)
+                        is_failed = result['failed_when_result'] = result['failed'] = self._task._resolve_conditional(self._task.failed_when, vars_copy)
+
+                        if not is_failed and (suppressed_exception := result.pop('exception', None)):
+                            result['failed_when_suppressed_exception'] = suppressed_exception
 
                 except AnsibleError as e:
                     result['failed'] = True
@@ -1129,7 +1132,7 @@ class TaskExecutor:
         # let action plugin override module, fallback to 'normal' action plugin otherwise
         elif self._shared_loader_obj.action_loader.has_plugin(self._task.action, collection_list=collections):
             handler_name = self._task.action
-        elif all((module_prefix in C.NETWORK_GROUP_MODULES, self._shared_loader_obj.action_loader.has_plugin(network_action, collection_list=collections))):
+        elif module_prefix in C.NETWORK_GROUP_MODULES and self._shared_loader_obj.action_loader.has_plugin(network_action, collection_list=collections):
             handler_name = network_action
             display.vvvv("Using network group action {handler} for {action}".format(handler=handler_name,
                                                                                     action=self._task.action),

ansible/executor/task_queue_manager.py

@@ -179,7 +179,7 @@ class TaskQueueManager:
             for fd in (STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO):
                 os.set_inheritable(fd, False)
         except Exception as ex:
-            self.warning(f"failed to set stdio as non inheritable: {ex}")
+            display.error_as_warning("failed to set stdio as non inheritable", exception=ex)
 
         self._callback_lock = threading.Lock()
 
@@ -269,7 +269,7 @@ class TaskQueueManager:
                     display.warning("Skipping callback '%s', as it does not create a valid plugin instance." % callback_name)
                     continue
             except Exception as ex:
-                display.warning_as_error(f"Failed to load callback plugin {callback_name!r}.", exception=ex)
+                display.error_as_warning(f"Failed to load callback plugin {callback_name!r}.", exception=ex)
                 continue
 
     def run(self, play):

ansible/module_utils/_internal/_ansiballz/_extensions/_debugpy.py

@@ -0,0 +1,97 @@
+"""
+Remote debugging support for AnsiballZ modules with debugpy.
+
+To use with VS Code:
+
+1) Choose an available port for VS Code to listen on (e.g. 5678).
+2) Ensure `debugpy` is installed for the interpreter(s) which will run the code being debugged.
+3) Create the following launch.json configuration
+
+    {
+        "version": "0.2.0",
+        "configurations": [
+            {
+                "name": "Python Debug Server",
+                "type": "debugpy",
+                "request": "attach",
+                "listen": {
+                    "host": "localhost",
+                    "port": 5678,
+                },
+            },
+            {
+                "name": "ansible-playbook main.yml",
+                "type": "debugpy",
+                "request": "launch",
+                "module": "ansible",
+                "args": [
+                    "playbook",
+                    "main.yml"
+                ],
+                "env": {
+                    "_ANSIBLE_ANSIBALLZ_DEBUGPY_CONFIG": "{\"host\": \"localhost\", \"port\": 5678}"
+                },
+                "console": "integratedTerminal",
+            }
+        ],
+        "compounds": [
+            {
+                "name": "Test Module Debugging",
+                "configurations": [
+                    "Python Debug Server",
+                    "ansible-playbook main.yml"
+                ],
+                "stopAll": true
+            }
+        ]
+    }
+
+4) Set any desired breakpoints.
+5) Configure the Run and Debug view to use the "Test Module Debugging" compound configuration.
+6) Press F5 to start debugging.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+import os
+import pathlib
+
+import typing as t
+
+
+@dataclasses.dataclass(frozen=True)
+class Options:
+    """Debugger options for debugpy."""
+
+    host: str = 'localhost'
+    """The host to connect to for remote debugging."""
+    port: int = 5678
+    """The port to connect to for remote debugging."""
+    connect: dict[str, object] = dataclasses.field(default_factory=dict)
+    """The options to pass to the `debugpy.connect` method."""
+    source_mapping: dict[str, str] = dataclasses.field(default_factory=dict)
+    """
+    A mapping of source paths to provide to debugpy.
+    This setting is used internally by AnsiballZ and is not required unless Ansible CLI commands are run from a different system than your IDE.
+    In that scenario, use this setting instead of configuring source mapping in your IDE.
+    The key is a path known to the IDE.
+    The value is the same path as known to the Ansible CLI.
+    Both file paths and directories are supported.
+    """
+
+
+def run(args: dict[str, t.Any]) -> None:  # pragma: nocover
+    """Enable remote debugging."""
+    import debugpy
+
+    options = Options(**args)
+    temp_dir = pathlib.Path(__file__).parent.parent.parent.parent.parent.parent
+    path_mapping = [[key, str(temp_dir / value)] for key, value in options.source_mapping.items()]
+
+    os.environ['PATHS_FROM_ECLIPSE_TO_PYTHON'] = json.dumps(path_mapping)
+
+    debugpy.connect((options.host, options.port), **options.connect)
+
+    pass  # A convenient place to put a breakpoint

ansible/module_utils/_internal/_ansiballz/_extensions/_pydevd.py

@@ -7,14 +7,12 @@ To use with PyCharm:
 2) Create a Python Debug Server using that port.
 3) Start the Python Debug Server.
 4) Ensure the correct version of `pydevd-pycharm` is installed for the interpreter(s) which will run the code being debugged.
-5) Configure Ansible with the `_ANSIBALLZ_DEBUGGER_CONFIG` option.
+5) Configure Ansible with the `_ANSIBALLZ_PYDEVD_CONFIG` option.
    See `Options` below for the structure of the debugger configuration.
    Example configuration using an environment variable:
-     export _ANSIBLE_ANSIBALLZ_DEBUGGER_CONFIG='{"module": "pydevd_pycharm", "settrace": {"host": "localhost", "port": 5678, "suspend": false}}'
+     export _ANSIBLE_ANSIBALLZ_PYDEVD_CONFIG='{"module": "pydevd_pycharm", "settrace": {"host": "localhost", "port": 5678, "suspend": false}}'
 6) Set any desired breakpoints.
 7) Run Ansible commands.
-
-A similar process should work for other pydevd based debuggers, such as Visual Studio Code, but they have not been tested.
 """
 
 from __future__ import annotations

ansible/module_utils/_internal/_traceback.py

@@ -80,7 +80,7 @@ def _is_module_traceback_enabled(event: TracebackEvent) -> bool:
             from ..basic import _PARSED_MODULE_ARGS
 
             _module_tracebacks_enabled_events = frozenset(
-                TracebackEvent[value.upper()] for value in _PARSED_MODULE_ARGS.get('_ansible_tracebacks_for')
+                TracebackEvent[value.upper()] for value in _PARSED_MODULE_ARGS.get('_ansible_tracebacks_for', [])
             )  # type: ignore[union-attr]
         except BaseException:
             return True  # if things failed early enough that we can't figure this out, assume we want a traceback for troubleshooting

ansible/module_utils/ansible_release.py

@@ -17,6 +17,6 @@
 
 from __future__ import annotations
 
-__version__ = '2.19.0rc1'
+__version__ = '2.19.1rc1'
 __author__ = 'Ansible, Inc.'
 __codename__ = "What Is and What Should Never Be"

ansible/module_utils/basic.py

@@ -1512,11 +1512,19 @@ class AnsibleModule(object):
         # strip no_log collisions
         kwargs = remove_values(kwargs, self.no_log_values)
 
-        # return preserved
+        # graft preserved values back on
         kwargs.update(preserved)
 
+        self._record_module_result(kwargs)
+
+    def _record_module_result(self, o: dict[str, t.Any]) -> None:
+        """
+        Temporary internal hook to enable modification/bypass of module result serialization.
+
+        Monkeypatched by ansible.netcommon for direct in-worker module execution.
+        """
         encoder = _json.get_module_encoder(_ANSIBLE_PROFILE, _json.Direction.MODULE_TO_CONTROLLER)
-        print('\n%s' % json.dumps(kwargs, cls=encoder))
+        print('\n%s' % json.dumps(o, cls=encoder))
 
     def exit_json(self, **kwargs) -> t.NoReturn:
         """ return from the module, without error """

ansible/module_utils/common/validation.py

@@ -376,7 +376,10 @@ def check_type_str(value, allow_conversion=True, param=None, prefix=''):
     if isinstance(value, string_types):
         return value
 
-    if allow_conversion and value is not None:
+    if value is None:
+        return ''  # approximate pre-2.19 templating None->empty str equivalency here for backward compatibility
+
+    if allow_conversion:
         return to_native(value, errors='surrogate_or_strict')
 
     msg = "'{0!r}' is not a string and conversion is not allowed".format(value)