We should not use assert for validation data. If the argument type is incorrect we raise a TypeError, if the type is correct but the value is invalid we raise a ValueError.

Same comment about assert.

Same comment about assert.

We need to validate self.subtype == 9 here before attempting to decode.

@ShaneHarvey How do I do that?

Something like:

if self.subtype != VECTOR_SUBTYPE:
   raise ValueError(...)

Look at as_uuid it should be the same as that validation:

        if self.subtype not in ALL_UUID_SUBTYPES:
            raise ValueError(f"cannot decode subtype {self.subtype} as a uuid")

An enum of bytes is a bit unusual. Can we change it to use ints? eg INT8 = 3

The naming convention that Geert used has meaning in both the first and last 4 bits, so I'd prefer it to stay as-is.

I don't see how the interpretation of the values here matters. Are you saying this is a bit flag?

The user doesn't see the value locally either. Given that the bson spec itself always uses integers I think we should use the integer form.

Add __slots__ = ("data", "dtype", "padding") to reduce the memory overhead of using this class.

Sure. How do I do type annotation for that?

None needed, e.g.

We could pass slots=True instead: https://docs.python.org/3/library/dataclasses.html#dataclasses.dataclass

Strange. And you're cool with that?

We have to add them manually instead of using slots=True.

class BinaryVector:
    """**(BETA)** Vector of numbers along with metadata for binary interoperability.

    :param data (Sequence[float | int]): Sequence of numbers representing the mathematical vector.
    :param dtype (:class:`bson.Binary.BinaryVectorDtype`):  The data type stored in binary
    :param padding (Optional[int] = 0): The number of bits in the final byte that are to be ignored
      when a vector element's size is less than a byte
      and the length of the vector is not a multiple of 8. Default is 0.

    .. versionadded:: 4.10
    """

    __slots__ = ("data", "dtype", "padding")

    def __init__(self, data, dtype, padding=0):
        self.data = data
        self.dtype = dtype
        self.padding = padding

Is this right? @blink1073

yep

Oh I didn't realize __slots__ with dataclass was problematic.

It should be sorted now

I don't see how the interpretation of the values here matters. Are you saying this is a bit flag?

Optional[int] -> int, unless padding=None is considered valid.

padding=None is expected when it is not a packed type

Is it? I see the code using padding=0 in that case.

Optional[int] -> int

Optional[bool] -> bool unless uncompressed=None is valid.

Why add an uncompressed option here at all? It looks like this option is irreversible because from_vector does not support the same option. Even if it did, is this option useful outside of test code?

Yeah, I think we should leave out uncompressed, it was a quality of life addition, but is not likely to be standardized.

Yes. It's irreversible. We don't yet provide an API to go from a full vector of zeros and ones to a packed bit vector.

Going in, you'd be using something like numpy.packbits

Let's omit it since it adds unneeded complexity at this point.

Done