Jinja NativeEnvironment字符串转字面量int问题及优化方案问询

现象困惑 #

执行以下代码：

import jinja2.nativetypes

env = jinja2.nativetypes.NativeEnvironment()
result = env.from_string('{{ x }}')
value = result.render(x='2')
print(type(value))

输出结果为：

<class 'int'>

原因分析 #

查看Jinja原生解析器代码发现，它会通过ast.parse()处理字符串节点并将其当作字面量解析。比如这里传入的字符串"2"会被解析成整数类型，但如果基于repr('2')解析的话，结果会符合预期（保持字符串类型）。官方明确表示这并非Bug，因此需要寻找规避方案。

当前实现的改写方案 #

我目前实现了以下改写，但不确定是否为最优方案，也不清楚原生代码中ast.parse/parse_literal的设计目的（是否是为了支持{{ "a+1" }}这类场景？）：

def _concat(values: t.Iterable[t.Any]) -> t.Optional[t.Any]:                              
    # based on native_concat from jinja2/nativetypes.py
    head = list(islice(values, 2))                                                        
    if not head:                                                                          
        return None                                                                       
                                                                                          
    if len(head) == 1:                                                                    
        raw = head[0]                                                                     
        # Removed this line.  Always return raw when single node.                  
        # if not isinstance(raw, str):                                                    
        return raw                                                                         
                                                                                          
    # Removed this else since we always return raw above.                                 
    # else:                                                                                
    if isinstance(values, GeneratorType):                                                 
        values = chain(head, values)    
                                               
    raw = "".join([str(v) for v in values])                                                 
                                                                                          
    try:                                                                                  
        return literal_eval(                                                              
            # In Python 3.10+ ast.literal_eval removes leading spaces/tabs                
            # from the given string. For backwards compatibility we need to                
            # parse the string ourselves without removing leading spaces/tabs.             
            parse(raw, mode="eval")                                                         
        )                                                                                  
    except (ValueError, SyntaxError, MemoryError):                                        
        return raw                                                                         
                                                                                          
                                                                                          
class FixedNativeEnvironment(jinja2.nativetypes.NativeEnvironment):                       
    # Fix for jinja issue #1904                                
    concat = staticmethod(_concat)  # type: ignore                                        
                                                                                          
                                                                                          
class FixedNativeTemplate(jinja2.nativetypes.NativeTemplate):                             
    environment_class = FixedNativeEnvironment    

提问 #

1. 是否有比上述方案更优的选择？
2. 该方案会破坏哪些使用场景？

更优替代方案 #

方案1：自定义过滤器（轻量化） #

通过自定义过滤器，仅针对需要保留字符串类型的变量生效，无需修改环境核心逻辑：

from jinja2.nativetypes import NativeEnvironment
from ast import literal_eval, parse

env = NativeEnvironment()

@env.filter
def keep_str(value):
    if isinstance(value, str):
        return value
    # 非字符串类型仍保留原生的字面量解析逻辑
    try:
        return literal_eval(parse(str(value), mode="eval"))
    except (ValueError, SyntaxError, MemoryError):
        return value

# 使用示例：渲染时通过过滤器保留字符串类型
template = env.from_string('{{ x|keep_str }}')
print(type(template.render(x='2')))  # 输出 <class 'str'>

这种方式更灵活，仅在需要的地方启用，不会影响全局默认行为。

方案2：重写变量解析逻辑（全局生效） #

如果需要全局生效且不想修改concat，可以继承NativeEnvironment并重写变量解析相关方法，仅对传入的变量类型做判断：

from jinja2.nativetypes import NativeEnvironment, NativeTemplate
from ast import literal_eval, parse

class FixedNativeEnvironment(NativeEnvironment):
    def _parse_literal(self, value):
        # 如果是传入的字符串变量，直接返回原字符串
        if isinstance(value, str):
            return value
        # 其他类型保留原生解析逻辑
        try:
            return literal_eval(parse(str(value), mode="eval"))
        except (ValueError, SyntaxError, MemoryError):
            return value

class FixedNativeTemplate(NativeTemplate):
    environment_class = FixedNativeEnvironment

这个方案比修改concat更精准，只针对变量的字面量解析环节，不会影响模板内字符串字面量的解析。

当前方案的破坏场景 #

你的方案修改了native_concat的核心逻辑，会直接破坏以下原生设计的场景：

• 单字符串节点的字面量解析：比如模板中写{{ "123" }}，原本会被解析为整数123，现在会保留为字符串"123"；{{ "[1,2,3]" }}原本解析为列表，现在会返回字符串。
• 动态表达式字符串解析：比如传入变量x = "a + 1"且模板中a已定义为1，原本{{ x }}会解析为2，现在会直接返回字符串"a + 1"。
• JSON格式字符串自动解析：比如传入x = '{"key": "val"}'，原本会自动解析为字典，现在会保留为字符串，导致后续依赖字典的逻辑出错。

原生native_concat对单字符串节点做字面量解析的设计目的，是为了支持将字符串形式的Python原生类型（数字、列表、字典等）自动还原为对应类型，你的方案完全禁用了这个特性。

内容的提问来源于stack exchange，提问作者rrauenza