How to Implement a Generic Builder Pattern in Python with Type Hinting?

Hey everyone! I've been experimenting with a builder pattern in Python, focusing on achieving proper type hinting. I'm trying to create a pipeline that accommodates a variable number of steps. The pipeline should have input type `TIn` and output type `TOut`, inferred from the inner steps, with `TIn` being the input for the first step and `TOut` for the last one. Here's the code I've come up with:

```python
TIn = TypeVar("TIn")
TOut = TypeVar("TOut")
TNext = TypeVar("TNext")

class Step(ABC, Generic[TIn, TOut]):
def execute(self, data: TIn) -> TOut:
...

def create_process(step: Step[TIn, TOut]) -> "Process[TIn, TOut]":
return Process.start_static(step)

class Process(Generic[TIn, TOut]):
def __init__(self, steps: list[Step] | None = None):
self.steps: list[Step] = steps or []

@classmethod
def start_class(cls, step: Step[TIn, TOut]) -> "Process[TIn, TOut]":
return cls([step])

@staticmethod
def start_static(step: Step[TIn, TOut]) -> "Process[TIn, TOut]":
return Process([step])

def add_step(self, step: Step[TOut, TNext]) -> "Process[TIn, TNext]":
return Process(self.steps + [step])

def execute(self, data: TIn) -> TOut:
current = data
for step in self.steps:
print(type(step))
current = step.execute(current)
return cast(TOut, current)

class IntToStr(Step[int, str]):
def execute(self, data: int) -> str:
return str(data)

class StrToBool(Step[str, bool]):
def execute(self, data: str) -> bool:
return data != ""

process = create_process(IntToStr()).add_step(StrToBool())
process = Process().add_step(IntToStr()).add_step(StrToBool())
process = Process.start_static(IntToStr()).add_step(StrToBool())
process = Process.start_class(IntToStr()).add_step(StrToBool())
process.execute(1)
```

From my experiments, the only way to correctly infer the input type is by using a method outside of my class. I'm curious if there's a workaround for this issue, or if I'm stuck with a factory method approach. It seems like `TIn` is not defined for the first step, leading to an unknown type being returned. Any insights would be greatly appreciated!