How to type annotate a 5x5 array stored as a tuple

Python Help
1

I have a function that returns a 5x5 matrix of float values. The only way I’ve found to write an annotation for this is

tuple[
    tuple[float, float, float, float, float],
    tuple[float, float, float, float, float],
    tuple[float, float, float, float, float],
    tuple[float, float, float, float, float],
    tuple[float, float, float, float, float],
]

Is that really the best way of writing this?

Before anyone suggests it, giving it an alias is basically pointless, as it’s only explicitly named once in my code. I could do sonething like t5 = tuple[float, float, float, float, float] and then use tuple[t5, t5, t5, t5, t5], but it’s still incredibly repetitive.

2

That’s currently the only way we have. There have been some proposals for shorthand notations for homogenous fixed sized tuples in the past, but they never went anywhere, most likely because it’s not common enough of a use-case.

If the fact that the tuple is 2D is more important than the fact that it’s exactly 5x5, there’s obviously also the option of using the less precise tuple[tuple[float, ...], ...], but I suspect you already know that.

3

I hadn’t worked out the correct incantation, so thanks for that, but I’m not sure how much better it is. To be honest, though, this isn’t a program that really needs typing in any case. It’s a one-off simulation, so type checks offer some protection against bugs to offset the fact that it’s hard to test because the output is probabilistic. The main reason for the question was simply “surely this can’t be the best option we have?” :slightly_smiling_face:

It does matter that the tuple is 5x5 (it’s indexed by an IntEnum value with 5 possibilities) but I doubt that Python’s typing is strong enough to check that anyway. So your form is probably sufficient for my needs.

One thought - if I’d made this into a NumPy array, would I be able to say it’s a 5x5 array with dtype float, or is numpy just as opaque to typing as tuples are?

1 Like
4

I’d suggest an alias:

T = TypeVar('T')
Quintuple: TypeAlias = tuple[T, T, T, T, T]
def function(m5x5: Quintuple[Quintuple[float]]) -> None:
    ...

Or in more recent Python:

type Quintuple[T] = tuple[T, T, T, T, T]
def function(m5x5: Quintuple[Quintuple[float]]) -> None:
    ...

Perhaps we should add homogeneous tuples to useful-types.

5

Thanks. I’ll remember that (as I said, for my immediate need, it’s not worth being that precise, but I may need it in the future).

It would be nice if generics could take integers as parameters, so you could do Multiple[T, 5], but I guess that’s too much to hope for at the moment.

2 Likes
6

With numpy arrays, the most detailed annotation would be
np.ndarray[tuple[Literal[5],Literal[5]], np.dtype[np.float64]].

That said, I think the typing API exposed by numpy currently supports shapes a lot less well than dtypes, so if you were using a type checker it would not necessarily check or infer the correct shapes.

7

Can’t speak on the pure python side but I’ve always felt it was a code smell with numpy to require specific shapes.

I can get indicating the “major”-ness but I don’t see many people explicitly Fortran ordering with numpy.

8

There’s some experimental shape typing support in numpy, and is an ongoing work in progress:

It’s very much something that will be awesome once it’s all figured out; shape typing in it’s entirety is a very difficult problem, but it’s definitely a huge interest.

To quote one of the main developers of it from Rank-typing · Issue #539 · numpy/numtype · GitHub

At runtime it’s trivially simple, because it’s just an int. But helpfuly describing it using static typing is quite the opposite, and is probably the biggest typing-challenge I’ve ever had to solve.