Hello, What you’re running into is a real limitation (and design trade-off) of Python’s static typing: shape (length) and element type are only strictly enforceable for tuples, not for general sequences.

That said, you can get very close to "the best of both worlds" with a few established patterns.

1. Why tuple[float, float, float] is strict (and complains)
   def to_global(point: tuple[float, float, float]) -> ...

This is the most precise type:

Exactly 3 elements

Each element is float

Immutable

The warning you see when calling:

to_global([1, 2, 3])

is correct behavior from the type checker:

list[int] is not a tuple[float, float, float]

Type checkers intentionally do not assume implicit conversion (int → float) or structural compatibility here

At runtime it works, but static typing is doing its job.

2. Why Sequence[float] is too loose
   def to_global(point: Sequence[float]) -> ...

This expresses:

"Indexable"

"Elements are floats"

❌ No length guarantee

So [1, 2] is valid statically, even though it explodes at runtime.

Python’s type system currently cannot express "a sequence of length exactly 3" — except with tuples.

3. Recommended solution: accept broad input, normalize internally

The most Pythonic and type-safe approach is:

Accept any reasonable sequence of numbers

Convert once at the boundary

Work internally with a strict type

from collections.abc import Sequence

Vector3 = tuple[float, float, float]

def to_global(point: Sequence[float]) -> Vector3:
if len(point) != 3:
raise ValueError("Expected a sequence of length 3")

x, y, z = map(float, point)
return (x, y, z)

Benefits:

✅ Accepts list[int], tuple[int, int, int], numpy arrays, etc.

✅ Enforces length at runtime

✅ Converts to a known, immutable internal representation

✅ Type checker is happy

✅ Callers get a precise return type

This is the pattern used by many numeric libraries (including parts of NumPy, Pydantic, and scientific Python code).

4. If you want static length checking: overloads

If you really want to help type checkers catch mistakes at call sites, you can use overloads:

from typing import overload, Sequence

Vector3 = tuple[float, float, float]

@overload
def to_global(point: tuple[float, float, float]) -> Vector3: ...
@overload
def to_global(point: Sequence[float]) -> Vector3: ...

def to_global(point: Sequence[float]) -> Vector3:
if len(point) != 3:
raise ValueError("Expected length 3")
return tuple(map(float, point)) # type: ignore[return-value]

This tells the type checker:

"Tuples of exactly 3 floats are ideal"

"Other sequences are allowed but checked at runtime"

5. Bonus: expressing "not mutated" (const-like behavior)

Python typing has no general const keyword, but you already get immutability guarantees via types:

Best options:

Use tuple (immutable by design)

Accept Sequence[T], not MutableSequence[T]

def to_global(point: Sequence[float]) -> Vector3:
...

This explicitly communicates:

"I will read from this, not mutate it."

Static type checkers will prevent accidental mutation like:

point[0] = 1.0 # ❌ error: Sequence is read-only