如何以Pythonic方式扩展Builder模式实现流畅链式调用

针对该CDK特定场景，官方API已经原生支持Chain实例拼接，是目前最优的无副作用方案：
你可以先把需要复用的逻辑封装为独立的Chain实例：

from aws_cdk import aws_stepfunctions as step_fn
from aws_cdk import core

app = core.App()

# 封装复用的foo逻辑
def get_foo_chain(scope: core.Construct) -> step_fn.Chain:
    return step_fn.Chain.start(
        step_fn.Pass(scope, 'foo1')
    ).next(
        step_fn.Pass(scope, 'foo2')
    )

调用时直接通过原有next方法拼接即可，完全保留链式调用的可读性：

state_machine = step_fn.Chain.start(
    step_fn.Pass(app, 'start')
).next(
    get_foo_chain(app)
).next(
    step_fn.Pass(app, 'bar')
)

该方案完全符合CDK设计规范，没有任何全局污染，可维护性极强。

如果是自定义Builder类，或使用的第三方Builder没有提供实例拼接能力，可以使用以下两种无全局副作用的方案实现流畅的链式扩展：

方案1：轻量包装类扩展 #

通过代理模式实现的包装类，仅在使用时生效，完全不修改原类的全局状态：

class ChainExt:
    def __init__(self, chain: step_fn.Chain):
        self._chain = chain
    
    # 自定义扩展方法
    def foo(self, scope: core.Construct) -> 'ChainExt':
        self._chain = self._chain.next(
            step_fn.Pass(scope, 'foo1')
        ).next(
            step_fn.Pass(scope, 'foo2')
        )
        return self
    
    # 透传原Builder的所有属性和方法
    def __getattr__(self, item):
        attr = getattr(self._chain, item)
        if callable(attr):
            def wrapper(*args, **kwargs):
                res = attr(*args, **kwargs)
                # 返回值是原Builder类型则继续包装，保证链式调用连贯
                if isinstance(res, step_fn.Chain):
                    self._chain = res
                    return self
                return res
            return wrapper
        return attr
    
    # 提取原始Builder实例
    @property
    def raw(self) -> step_fn.Chain:
        return self._chain

调用方式和原生链式语法完全一致：

state_machine = ChainExt(step_fn.Chain.start(
    step_fn.Pass(app, 'start')
)).foo(app).next(
    step_fn.Pass(app, 'bar')
).raw

方案2：实现pipe方法（通用流式惯例） #

如果可以自定义Builder的实现，新增一个pipe方法是Python生态最通用的扩展方式，pandas、polars等主流库都采用该设计：

class CustomBuilder:
    # ... 原有Builder的其他实现
    def pipe(self, func, *args, **kwargs):
        """接收处理函数，返回处理后的新Builder实例"""
        return func(self, *args, **kwargs)

调用时直接在链式流程中插入自定义方法即可，不需要调整原有代码顺序：

def foo(builder: CustomBuilder) -> CustomBuilder:
    return builder.next(...).next(...)

# 链式调用完全连贯
builder = CustomBuilder.start(...).pipe(foo).next(...)

如果是从零设计Builder类，更推荐新增extend/append这类方法，直接支持拼接同类型的Builder实例，即可轻松实现逻辑复用，是投入产出比最高的方案。

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