BizHawkClient: Fix typing mistake

[Zunawe]

What is this fixing or adding?

The type Iterable[int] was used in a few places to indicate some sort of list of integers. Specifically something that can be passed into the bytes constructor. It's almost accurate, but not specific enough. A generator that never stops iterating fits Iterable[int], but would be wrong here.

The actual type for what you can pass into bytes according to my IDE is Iterable[SupportsIndex] | SupportsIndex | SupportsBytes | ReadableBuffer. From what I can tell, Sequence[int] is a subset of Iterable[SupportsIndex], and it's still concise and descriptive.

How was this tested?

Did a few isinstances in a REPL and briefly opened an Emerald patch to make sure things didn't crash.

[Exempt-Medic]

LGTM and hits all the instances of this

[beauxq]

An infinite generator would be a problem with almost everything typed with Iterable.
I think that's not really a problem with the Iterable typing. It's a problem with making and using an infinite generator.

But this change is not bad if you want it.

The thing I would be more concerned about is typing.List for read_list and guard_list and write_list. That makes it more difficult to get valid typing at the call site.
Those could be changed to Iterable or Sequence to make things easier for callers.

Generally, if you're not mutating the parameter in the function, you should use an immutable interface for the parameter type annotation.

[beauxq]

BTW, typing.Collection is another interface that would work for these that doesn't allow an infinite generator.
It would be less restrictive than Sequence.

But after thinking about it more, I think Sequence is the better option, but for a different reason:
A set fits both Iterable and Collection, but a set is an arbitrary order.
I think the order is important for all of these things. (You don't want bytes in any arbitrary order, right?)
So Sequence makes it more clear that the order is important.

So I would use Sequence for the outer type and the inner type (and even the return type, but that's less clear-cut).

async def guarded_read(ctx: BizHawkContext,
                       read_list: typing.Sequence[typing.Tuple[int, int, str]],
                       guard_list: typing.Sequence[typing.Tuple[int, typing.Sequence[int], str]]) -> typing.Optional[typing.Sequence[bytes]]:

and a similar change in the other functions

[Zunawe]

Someone's mypy complained about Iterable for these reasons. I doubt people were considering passing an infinite generator into these functions, but I'd still call it a problem with the typing rather than strictly user error.

Sequence for the guard/read/write lists makes sense. I've changed that.

I'm not sure it makes sense to change the return type though, since we're just explicitly creating and returning a list. No reason to add extra abstraction.