fake-bpy-module 20241103__py3-none-any.whl → 20241111__py3-none-any.whl

gpu/__init__.pyi

@@ -22,7 +22,13 @@ A batch contains the necessary data to perform the drawing.
 That includes an obligatory *Vertex Buffer* and an optional *Index Buffer*,
 each of which is described in more detail in the following sections.
 A batch also defines a draw type.
-Typical draw types are POINTS, LINES and TRIS.
+Typical draw types are POINTS
+
+, LINES
+
+ and TRIS
+
+.
 The draw type determines how the data will be interpreted and drawn.
 
 
@@ -78,7 +84,9 @@ indices = ((0, 1, 2), (2, 1, 3))
 ibo = gpu.types.GPUIndexBuf(type='TRIS', seq=indices)
 ```
 
-Here the first tuple in indices describes which vertices should be used for the first triangle
+Here the first tuple in indices
+
+ describes which vertices should be used for the first triangle
 (same for the second tuple).
 Note how the diagonal vertices 1 and 2 are shared between both triangles.
 
@@ -92,12 +100,18 @@ Typically multiple shaders are linked together into a *Program*.
 However, in the Blender Python API the term *Shader* refers to an OpenGL Program.
 Every gpu.types.GPUShader consists of a vertex shader, a fragment shader and an optional geometry shader.
 For common drawing tasks there are some built-in shaders accessible from gpu.shader.from_builtin
-with an identifier such as UNIFORM_COLOR or FLAT_COLOR.
+with an identifier such as UNIFORM_COLOR
+
+ or FLAT_COLOR
+
+.
 
 Every shader defines a set of attributes and uniforms that have to be set in order to use the shader.
 Attributes are properties that are set using a vertex buffer and can be different for individual vertices.
 Uniforms are properties that are constant per draw call.
-They can be set using the shader.uniform_* functions after the shader has been bound.
+They can be set using the shader.uniform_*
+
+ functions after the shader has been bound.
 
 
 --------------------
@@ -123,7 +137,7 @@ This is called Offscreen Rendering.
 In Blender Offscreen Rendering is done using the gpu.types.GPUOffScreen type.
 
 [WARNING]
-GPUOffScreen objects are bound to the OpenGL context they have been created in.
+gpu.types.GPUOffScreen objects are bound to the OpenGL context they have been created in.
 This means that once Blender discards this context (i.e. the window is closed),
 the offscreen instance will be freed.
 

gpu/matrix/__init__.pyi

@@ -86,7 +86,7 @@ def reset():
 def scale(scale):
     """Scale the current stack matrix.
 
-    :param scale: Scale the current stack matrix.
+    :param scale: Scale the current stack matrix with 2 or 3 floats.
     """
 
 def scale_uniform(scale: float):
@@ -99,5 +99,5 @@ def scale_uniform(scale: float):
 def translate(offset):
     """Scale the current stack matrix.
 
-    :param offset: Translate the current stack matrix.
+    :param offset: Translate the current stack matrix with 2 or 3 floats.
     """

gpu/state/__init__.pyi

@@ -17,14 +17,22 @@ def blend_set(mode: str):
     """Defines the fixed pipeline blending equation.
 
         :param mode: The type of blend mode.
-    * NONE No blending.
-    * ALPHA The original color channels are interpolated according to the alpha value.
-    * ALPHA_PREMULT The original color channels are interpolated according to the alpha value with the new colors pre-multiplied by this value.
-    * ADDITIVE The original color channels are added by the corresponding ones.
-    * ADDITIVE_PREMULT The original color channels are added by the corresponding ones that are pre-multiplied by the alpha value.
-    * MULTIPLY The original color channels are multiplied by the corresponding ones.
-    * SUBTRACT The original color channels are subtracted by the corresponding ones.
-    * INVERT The original color channels are replaced by its complementary color.
+
+    NONE No blending.
+
+    ALPHA The original color channels are interpolated according to the alpha value.
+
+    ALPHA_PREMULT The original color channels are interpolated according to the alpha value with the new colors pre-multiplied by this value.
+
+    ADDITIVE The original color channels are added by the corresponding ones.
+
+    ADDITIVE_PREMULT The original color channels are added by the corresponding ones that are pre-multiplied by the alpha value.
+
+    MULTIPLY The original color channels are multiplied by the corresponding ones.
+
+    SUBTRACT The original color channels are subtracted by the corresponding ones.
+
+    INVERT The original color channels are replaced by its complementary color.
         :type mode: str
     """
 

gpu/types/__init__.pyi

@@ -41,8 +41,7 @@ class GPUBatch:
     def draw_range(
         self, program: GPUShader, *, elem_start: int = 0, elem_count: int = 0
     ):
-        """Run the drawing program with the parameters assigned to the batch. Only draw
-        the elem_count elements of the index buffer starting at elem_start
+        """Run the drawing program with the parameters assigned to the batch. Only draw the elem_count elements of the index buffer starting at elem_start.
 
                 :param program: Program that performs the drawing operations.
                 :type program: GPUShader
@@ -93,7 +92,7 @@ class GPUFrameBuffer:
         """Fill color, depth and stencil textures with specific value.
         Common values: color=(0.0, 0.0, 0.0, 1.0), depth=1.0, stencil=0.
 
-                :param color: float sequence each representing (r, g, b, a).
+                :param color: Sequence of 3 or 4 floats representing (r, g, b, a).
                 :param depth: depth value.
                 :type depth: float | None
                 :param stencil: stencil value.
@@ -272,11 +271,10 @@ class GPUShader:
         :rtype: int
         """
 
-    def attrs_info_get(self) -> tuple:
+    def attrs_info_get(self):
         """Information about the attributes used in the Shader.
 
         :return: tuples containing information about the attributes in order (name, type)
-        :rtype: tuple
         """
 
     def bind(self):
@@ -315,22 +313,20 @@ class GPUShader:
         :rtype: int
         """
 
-    def uniform_bool(self, name: str, value: bool):
+    def uniform_bool(self, name: str, value):
         """Specify the value of a uniform variable for the current program object.
 
         :param name: Name of the uniform variable whose value is to be changed.
         :type name: str
         :param value: Value that will be used to update the specified uniform variable.
-        :type value: bool
         """
 
-    def uniform_float(self, name: str, value: list[float]):
+    def uniform_float(self, name: str, value):
         """Specify the value of a uniform variable for the current program object.
 
         :param name: Name of the uniform variable whose value is to be changed.
         :type name: str
         :param value: Value that will be used to update the specified uniform variable.
-        :type value: list[float]
         """
 
     def uniform_from_name(self, name: str) -> int:
@@ -342,13 +338,12 @@ class GPUShader:
         :rtype: int
         """
 
-    def uniform_int(self, name: str, seq: list[int]):
+    def uniform_int(self, name: str, seq):
         """Specify the value of a uniform variable for the current program object.
 
         :param name: name of the uniform variable whose value is to be changed.
         :type name: str
         :param seq: Value that will be used to update the specified uniform variable.
-        :type seq: list[int]
         """
 
     def uniform_sampler(self, name: str, texture: GPUTexture):
@@ -360,15 +355,12 @@ class GPUShader:
         :type texture: GPUTexture
         """
 
-    def uniform_vector_float(
-        self, location: int, buffer: list[float], length: int, count: int
-    ):
+    def uniform_vector_float(self, location: int, buffer, length: int, count: int):
         """Set the buffer to fill the uniform.
 
                 :param location: Location of the uniform variable to be modified.
                 :type location: int
                 :param buffer: The data that should be set. Can support the buffer protocol.
-                :type buffer: list[float]
                 :param length: Size of the uniform data type:
 
         1: float
@@ -464,12 +456,7 @@ class GPUShaderCreateInfo:
         """
 
     def image(
-        self,
-        slot: int,
-        format: str,
-        type: str,
-        name: str,
-        qualifiers: set = {"NO_RESTRICT"},
+        self, slot: int, format: str, type: str, name: str, qualifiers={"NO_RESTRICT"}
     ):
         """Specify an image resource used for arbitrary load and store operations.
 
@@ -637,7 +624,6 @@ class GPUShaderCreateInfo:
         - NO_RESTRICT
         - READ
         - WRITE
-                :type qualifiers: set
         """
 
     def local_group_size(self, x: int, y: int = -1, z: int = -1):
@@ -651,7 +637,7 @@ class GPUShaderCreateInfo:
         :type z: int
         """
 
-    def push_constant(self, type: str, name: str, size=0):
+    def push_constant(self, type: str, name: str, size: int = 0):
         """Specify a global access constant.
 
                 :param type: One of these types:
@@ -689,6 +675,7 @@ class GPUShaderCreateInfo:
                 :param name: Name of the constant.
                 :type name: str
                 :param size: If not zero, indicates that the constant is an array with the specified size.
+                :type size: int
         """
 
     def sampler(self, slot: int, type: str, name: str):
@@ -773,7 +760,7 @@ class GPUShaderCreateInfo:
         """
 
     def uniform_buf(self, slot: int, type_name: str, name: str):
-        """Specify a uniform variable whose type can be one of those declared in typedef_source.
+        """Specify a uniform variable whose type can be one of those declared in `gpu.types.GPUShaderCreateInfo.typedef_source`.
 
         :param slot: The uniform variable index.
         :type slot: int
@@ -991,7 +978,7 @@ class GPUTexture:
                 :param format: The format that describes the content of a single item.
         Possible values are FLOAT, INT, UINT, UBYTE, UINT_24_8 and 10_11_11_REV.
                 :type format: str
-                :param value: sequence each representing the value to fill.
+                :param value: Sequence each representing the value to fill. Sizes 1..4 are supported.
         """
 
     def read(self):
@@ -1009,13 +996,11 @@ class GPUUniformBuf:
 class GPUVertBuf:
     """Contains a VBO."""
 
-    def attr_fill(self, id: int | str, data: list[float]):
+    def attr_fill(self, id, data):
         """Insert data into the buffer for a single attribute.
 
         :param id: Either the name or the id of the attribute.
-        :type id: int | str
-        :param data: Sequence of data that should be stored in the buffer
-        :type data: list[float]
+        :param data: Buffer or sequence of data that should be stored in the buffer
         """
 
 class GPUVertFormat:

gpu_extras/batch/__init__.pyi

@@ -4,16 +4,16 @@ import typing_extensions
 import gpu.types
 
 def batch_for_shader(
-    shader: gpu.types.GPUShader, type: str, content: dict, *, indices=None
+    shader: gpu.types.GPUShader, type: str, content, *, indices=None
 ) -> gpu.types.GPUBatch:
     """Return a batch already configured and compatible with the shader.
 
-    :param shader: shader for which a compatible format will be computed.
-    :type shader: gpu.types.GPUShader
-    :param type: "'POINTS', 'LINES', 'TRIS' or 'LINES_ADJ'".
-    :type type: str
-    :param content: Maps the name of the shader attribute with the data to fill the vertex buffer.
-    :type content: dict
-    :return: compatible batch
-    :rtype: gpu.types.GPUBatch
+        :param shader: shader for which a compatible format will be computed.
+        :type shader: gpu.types.GPUShader
+        :param type: "'POINTS', 'LINES', 'TRIS' or 'LINES_ADJ'".
+        :type type: str
+        :param content: Maps the name of the shader attribute with the data to fill the vertex buffer.
+    For the dictionary values see documentation for `gpu.types.GPUVertBuf.attr_fill` data argument.
+        :return: compatible batch
+        :rtype: gpu.types.GPUBatch
     """

gpu_extras/presets/__init__.pyi

@@ -4,24 +4,17 @@ import typing_extensions
 import gpu.types
 import mathutils
 
-def draw_circle_2d(
-    position: collections.abc.Sequence[float] | mathutils.Vector,
-    color,
-    radius: float,
-    *,
-    segments: int | None = None,
-):
+def draw_circle_2d(position, color, radius: float, *, segments=None):
     """Draw a circle.
 
-        :param position: Position where the circle will be drawn.
-        :type position: collections.abc.Sequence[float] | mathutils.Vector
-        :param color: Color of the circle. To use transparency GL_BLEND has to be enabled.
+        :param position: 2D position where the circle will be drawn.
+        :param color: Color of the circle (RGBA).
+    To use transparency blend must be set to ALPHA, see: `gpu.state.blend_set`.
         :param radius: Radius of the circle.
         :type radius: float
         :param segments: How many segments will be used to draw the circle.
     Higher values give better results but the drawing will take longer.
     If None or not specified, an automatic value will be calculated.
-        :type segments: int | None
     """
 
 def draw_texture_2d(

idprop/types/__init__.pyi

@@ -40,11 +40,10 @@ class IDPropertyGroup:
     def to_dict(self):
         """Return a purely Python version of the group."""
 
-    def update(self, other: dict | typing_extensions.Self):
+    def update(self, other):
         """Update key, values.
 
         :param other: Updates the values in the group with this.
-        :type other: dict | typing_extensions.Self
         """
 
     def values(self):

imbuf/__init__.pyi

@@ -18,11 +18,10 @@ import imbuf.types
 
 from . import types as types
 
-def load(filepath: bytes | str) -> imbuf.types.ImBuf:
+def load(filepath) -> imbuf.types.ImBuf:
     """Load an image from a file.
 
     :param filepath: the filepath of the image.
-    :type filepath: bytes | str
     :return: the newly loaded image.
     :rtype: imbuf.types.ImBuf
     """
@@ -35,11 +34,10 @@ def new(size) -> imbuf.types.ImBuf:
     :rtype: imbuf.types.ImBuf
     """
 
-def write(image: imbuf.types.ImBuf, filepath: bytes | str = image.filepath):
+def write(image: imbuf.types.ImBuf, filepath=image.filepath):
     """Write an image.
 
     :param image: the image to write.
     :type image: imbuf.types.ImBuf
     :param filepath: Optional filepath of the image (fallback to the images file path).
-    :type filepath: bytes | str
     """

mathutils/__init__.pyi

@@ -422,18 +422,10 @@ class Euler:
                 :param other:
         """
 
-    def rotate(
-        self,
-        other: Matrix
-        | Quaternion
-        | collections.abc.Sequence[collections.abc.Sequence[float]]
-        | collections.abc.Sequence[float]
-        | typing_extensions.Self,
-    ):
+    def rotate(self, other):
         """Rotates the euler by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: Matrix | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float] | typing_extensions.Self
         """
 
     def rotate_axis(self, axis: str, angle: float):
@@ -620,35 +612,24 @@ class Matrix:
         """
 
     @classmethod
-    def LocRotScale(
-        cls,
-        location: Vector | collections.abc.Sequence[float] | None,
-        rotation: Euler | Quaternion | collections.abc.Sequence[float] | None,
-        scale: Vector | collections.abc.Sequence[float] | None,
-    ) -> typing_extensions.Self:
+    def LocRotScale(cls, location, rotation, scale) -> typing_extensions.Self:
         """Create a matrix combining translation, rotation and scale,
         acting as the inverse of the decompose() method.Any of the inputs may be replaced with None if not needed.
 
                 :param location: The translation component.
-                :type location: Vector | collections.abc.Sequence[float] | None
-                :param rotation: The rotation component.
-                :type rotation: Euler | Quaternion | collections.abc.Sequence[float] | None
+                :param rotation: The rotation component as a 3x3 matrix, quaternion, euler or None for no rotation.
                 :param scale: The scale component.
-                :type scale: Vector | collections.abc.Sequence[float] | None
-                :return: Combined transformation matrix.
+                :return: Combined transformation as a 4x4 matrix.
                 :rtype: typing_extensions.Self
         """
 
     @classmethod
-    def OrthoProjection(
-        cls, axis: Vector | collections.abc.Sequence[float] | str, size: int
-    ) -> typing_extensions.Self:
+    def OrthoProjection(cls, axis, size: int) -> typing_extensions.Self:
         """Create a matrix to represent an orthographic projection.
 
                 :param axis: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ'],
         where a single axis is for a 2D matrix.
         Or a vector for an arbitrary axis
-                :type axis: Vector | collections.abc.Sequence[float] | str
                 :param size: The size of the projection matrix to construct [2, 4].
                 :type size: int
                 :return: A new projection matrix.
@@ -656,12 +637,7 @@ class Matrix:
         """
 
     @classmethod
-    def Rotation(
-        cls,
-        angle: float,
-        size: int,
-        axis: Vector | collections.abc.Sequence[float] | str | None = "",
-    ) -> typing_extensions.Self:
+    def Rotation(cls, angle: float, size: int, axis) -> typing_extensions.Self:
         """Create a matrix representing a rotation.
 
                 :param angle: The angle of rotation desired, in radians.
@@ -670,7 +646,6 @@ class Matrix:
                 :type size: int
                 :param axis: a string in ['X', 'Y', 'Z'] or a 3D Vector Object
         (optional when size is 2).
-                :type axis: Vector | collections.abc.Sequence[float] | str | None
                 :return: A new rotation matrix.
                 :rtype: typing_extensions.Self
         """
@@ -695,7 +670,7 @@ class Matrix:
         """
 
     @classmethod
-    def Shear(cls, plane: str, size: int, factor: float) -> typing_extensions.Self:
+    def Shear(cls, plane: str, size: int, factor) -> typing_extensions.Self:
         """Create a matrix to represent an shear transformation.
 
                 :param plane: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ'],
@@ -703,9 +678,7 @@ class Matrix:
                 :type plane: str
                 :param size: The size of the shear matrix to construct [2, 4].
                 :type size: int
-                :param factor: The factor of shear to apply. For a 3 or 4 size matrix
-        pass a pair of floats corresponding with the plane axis.
-                :type factor: float
+                :param factor: The factor of shear to apply. For a 2 size matrix use a single float. For a 3 or 4 size matrix pass a pair of floats corresponding with the plane axis.
                 :return: A new shear matrix.
                 :rtype: typing_extensions.Self
         """
@@ -739,11 +712,11 @@ class Matrix:
         :rtype: typing_extensions.Self
         """
 
-    def decompose(self) -> tuple[Vector, Quaternion, Vector]:
+    def decompose(self) -> Quaternion:
         """Return the translation, rotation, and scale components of this matrix.
 
-        :return: tuple of translation, rotation, and scale
-        :rtype: tuple[Vector, Quaternion, Vector]
+        :return: Tuple of translation, rotation, and scale.
+        :rtype: Quaternion
         """
 
     def determinant(self) -> float:
@@ -783,14 +756,12 @@ class Matrix:
 
         """
 
-    def inverted(self, fallback: typing.Any | None = None) -> typing_extensions.Self:
+    def inverted(self, fallback=None):
         """Return an inverted copy of the matrix.
 
                 :param fallback: return this when the inverse can't be calculated
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
-                :return: the inverted matrix or fallback when given.
-                :rtype: typing_extensions.Self
+                :return: The inverted matrix or fallback when given.
         """
 
     def inverted_safe(self) -> typing_extensions.Self:
@@ -831,18 +802,10 @@ class Matrix:
     def resize_4x4(self):
         """Resize the matrix to 4x4."""
 
-    def rotate(
-        self,
-        other: Euler
-        | Quaternion
-        | collections.abc.Sequence[collections.abc.Sequence[float]]
-        | collections.abc.Sequence[float]
-        | typing_extensions.Self,
-    ):
+    def rotate(self, other):
         """Rotates the matrix by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: Euler | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float] | typing_extensions.Self
         """
 
     def to_2x2(self) -> typing_extensions.Self:
@@ -1254,18 +1217,10 @@ class Quaternion:
         :rtype: typing_extensions.Self
         """
 
-    def rotate(
-        self,
-        other: Euler
-        | Matrix
-        | collections.abc.Sequence[collections.abc.Sequence[float]]
-        | collections.abc.Sequence[float]
-        | typing_extensions.Self,
-    ):
+    def rotate(self, other):
         """Rotates the quaternion by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: Euler | Matrix | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float] | typing_extensions.Self
         """
 
     def rotation_difference(
@@ -1294,11 +1249,10 @@ class Quaternion:
         :rtype: typing_extensions.Self
         """
 
-    def to_axis_angle(self) -> tuple[Vector, float]:
+    def to_axis_angle(self):
         """Return the axis, angle representation of the quaternion.
 
-        :return: axis, angle.
-        :rtype: tuple[Vector, float]
+        :return: Axis, angle.
         """
 
     def to_euler(
@@ -1333,13 +1287,13 @@ class Quaternion:
         :rtype: Matrix
         """
 
-    def to_swing_twist(self, axis) -> tuple[Quaternion, float]:
+    def to_swing_twist(self, axis: str):
         """Split the rotation into a swing quaternion with the specified
         axis fixed at zero, and the remaining twist rotation angle.
 
-                :param axis: twist axis as a string in ['X', 'Y', 'Z']
-                :return: swing, twist angle.
-                :rtype: tuple[Quaternion, float]
+                :param axis: Twist axis as a string in ['X', 'Y', 'Z'].
+                :type axis: str
+                :return: Swing, twist angle.
         """
 
     def __init__(self, seq=(1.0, 0.0, 0.0, 0.0)):
@@ -3644,33 +3598,27 @@ class Vector:
     def angle(
         self,
         other: collections.abc.Sequence[float] | typing_extensions.Self,
-        fallback: typing.Any | None = None,
-    ) -> float:
+        fallback=None,
+    ):
         """Return the angle between two vectors.
 
                 :param other: another vector to compare the angle with
                 :type other: collections.abc.Sequence[float] | typing_extensions.Self
                 :param fallback: return this when the angle can't be calculated (zero length vector),
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: angle in radians or fallback when given
-                :rtype: float
         """
 
     def angle_signed(
-        self,
-        other: collections.abc.Sequence[float] | typing_extensions.Self,
-        fallback: typing.Any,
-    ) -> float:
+        self, other: collections.abc.Sequence[float] | typing_extensions.Self, fallback
+    ):
         """Return the signed angle between two 2D vectors (clockwise is positive).
 
                 :param other: another vector to compare the angle with
                 :type other: collections.abc.Sequence[float] | typing_extensions.Self
                 :param fallback: return this when the angle can't be calculated (zero length vector),
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any
                 :return: angle in radians or fallback when given
-                :rtype: float
         """
 
     def copy(self) -> typing_extensions.Self:
@@ -3680,15 +3628,12 @@ class Vector:
         :rtype: typing_extensions.Self
         """
 
-    def cross(
-        self, other: collections.abc.Sequence[float] | typing_extensions.Self
-    ) -> typing_extensions.Self:
+    def cross(self, other: collections.abc.Sequence[float] | typing_extensions.Self):
         """Return the cross product of this vector and another.
 
         :param other: The other vector to perform the cross product with.
         :type other: collections.abc.Sequence[float] | typing_extensions.Self
-        :return: The cross product.
-        :rtype: typing_extensions.Self
+        :return: The cross product as a vector or a float when 2D vectors are used.
         """
 
     def dot(
@@ -3789,18 +3734,10 @@ class Vector:
         :rtype: typing_extensions.Self
         """
 
-    def rotate(
-        self,
-        other: Euler
-        | Matrix
-        | Quaternion
-        | collections.abc.Sequence[collections.abc.Sequence[float]]
-        | collections.abc.Sequence[float],
-    ):
+    def rotate(self, other):
         """Rotate the vector by a rotation value.
 
         :param other: rotation component of mathutils value
-        :type other: Euler | Matrix | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float]
         """
 
     def rotation_difference(
@@ -3819,7 +3756,7 @@ class Vector:
         self,
         other: collections.abc.Sequence[float] | typing_extensions.Self,
         factor: float,
-        fallback: typing.Any | None = None,
+        fallback=None,
     ) -> typing_extensions.Self:
         """Returns the interpolation of two non-zero vectors (spherical coordinates).
 
@@ -3829,7 +3766,6 @@ class Vector:
                 :type factor: float
                 :param fallback: return this when the vector can't be calculated (zero length vector or direct opposites),
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: The interpolated vector.
                 :rtype: typing_extensions.Self
         """
@@ -3866,13 +3802,12 @@ class Vector:
         :rtype: Quaternion
         """
 
-    def to_tuple(self, precision: int = -1) -> tuple:
+    def to_tuple(self, precision: int = -1):
         """Return this vector as a tuple with.
 
         :param precision: The number to round the value to in [-1, 21].
         :type precision: int
         :return: the values of the vector rounded by precision
-        :rtype: tuple
         """
 
     def zero(self):