What is the best practice to type / type-narrow tuples or lists where the elements can be anything, but I don't care what they are?

[aakhavanQC]

I'm writing a pydantic validator to conver a two-element tuple into a pydantic model with two named attributes.

class MyModel(BaseModel):
    foo: int # this type doesn't really matter for the example
    bar: int

    @model_validator(mode="before"):
    @classmethod
    def from_tuple(cls, value: Any) -> Any:
        if not isinstance(value, tuple):
            return value

        # value is now tuple[Unknown, ...]
        # any usage of value then creates an error
        if len(value) == 2:
            return {"foo": value[0], "bar": value[1]}

        return value

I need to check that there are at least 2 elements (or I could wrap it in a try/except IndexError), but obviously that complains because it's a tuple[Unknown, ...]. As do value[0] and value[1]. The thing is that it doesn't matter because the built-in pydantic validation will then check that the elements are both int, and it's expecting arbitrary types for its inputs.

I could

• add # type: ignore to all references to value
• explicitly cast to tuple[Any, ...]
• type narrow value[0] and value[1] as ints, wrapped in a try/except IndexError (which is redundant because pydantic will then check the elements are ints again)
• do the above but with a wrap-mode validator (which means I have to handle all validation manually)

I'm not a huge fan of any these, but it's not clear to me that there is a great way just with types. Am I missing anything?

[erictraut]

By default, pyright doesn't report any errors with the above code. I'm guessing that you've enabled strict-mode type checking?

One option that you haven't listed above is to write your own user-defined type guard function using TypeIs:

def is_tuple(val: object) -> TypeIs[tuple[Any, ...]]:
    return isinstance(val, tuple)

[aakhavanQC]

Thanks for the suggestion! I had actually tried a typeguard, but for the types of the elements too. That ran into the same problem, but just adding the typeguard for the tuple is a nice way of resolving everything.

[aakhavanQC]

(and yes, it's in strict mode)