fake-bpy-module 20240411__py3-none-any.whl → 20240418__py3-none-any.whl

mathutils/bvhtree/__init__.pyi

@@ -1,3 +1,8 @@
+"""
+BVH tree structures for proximity searches and ray casts on geometry.
+
+"""
+
 import typing
 import bmesh.types
 import bpy.types
@@ -9,12 +14,13 @@ class BVHTree:
     """ """
 
     @classmethod
-    def FromBMesh(cls, bmesh: bmesh.types.BMesh, epsilon=0.0):
+    def FromBMesh(cls, bmesh: bmesh.types.BMesh, epsilon: float = 0.0):
         """BVH tree based on `BMesh` data.
 
         :param bmesh: BMesh data.
         :type bmesh: bmesh.types.BMesh
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
+        :type epsilon: float
         """
         ...
 
@@ -26,7 +32,7 @@ class BVHTree:
         deform: bool = True,
         render=False,
         cage: bool = False,
-        epsilon=0.0,
+        epsilon: float = 0.0,
     ):
         """BVH tree based on `Object` data.
 
@@ -40,11 +46,14 @@ class BVHTree:
         :param cage: Use modifiers cage.
         :type cage: bool
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
+        :type epsilon: float
         """
         ...
 
     @classmethod
-    def FromPolygons(cls, vertices, polygons, all_triangles: bool = False, epsilon=0.0):
+    def FromPolygons(
+        cls, vertices, polygons, all_triangles: bool = False, epsilon: float = 0.0
+    ):
         """BVH tree constructed geometry passed in as arguments.
 
         :param vertices: float triplets each representing (x, y, z)
@@ -52,14 +61,16 @@ class BVHTree:
         :param all_triangles: Use when all polygons are triangles for more efficient conversion.
         :type all_triangles: bool
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
+        :type epsilon: float
         """
         ...
 
-    def find_nearest(self, origin, distance=1.84467e19):
+    def find_nearest(self, origin, distance: float = 1.84467e19) -> tuple:
         """Find the nearest element (typically face index) to a point.
 
                 :param origin:
                 :param distance: Maximum distance threshold.
+                :type distance: float
                 :return: Returns a tuple
         (`Vector` location, `Vector` normal, int index, float distance),
         Values will all be None if no hit is found.
@@ -67,18 +78,19 @@ class BVHTree:
         """
         ...
 
-    def find_nearest_range(self, origin, distance=1.84467e19):
+    def find_nearest_range(self, origin, distance: float = 1.84467e19) -> list:
         """Find the nearest elements (typically face index) to a point in the distance range.
 
                 :param origin:
                 :param distance: Maximum distance threshold.
+                :type distance: float
                 :return: Returns a list of tuples
         (`Vector` location, `Vector` normal, int index, float distance),
                 :rtype: list
         """
         ...
 
-    def overlap(self, other_tree: BVHTree) -> BVHTree:
+    def overlap(self, other_tree: BVHTree) -> list:
         """Find overlapping indices between 2 trees.
 
         :param other_tree: Other tree to perform overlap test on.
@@ -92,8 +104,8 @@ class BVHTree:
         self,
         origin: typing.Union[typing.Sequence[float], mathutils.Vector],
         direction: typing.Union[typing.Sequence[float], mathutils.Vector],
-        distance=None,
-    ):
+        distance: float = None,
+    ) -> tuple:
         """Cast a ray onto the mesh.
 
                 :param origin: Start location of the ray in object space.
@@ -101,6 +113,7 @@ class BVHTree:
                 :param direction: Direction of the ray in object space.
                 :type direction: typing.Union[typing.Sequence[float], mathutils.Vector]
                 :param distance: Maximum distance threshold.
+                :type distance: float
                 :return: Returns a tuple
         (`Vector` location, `Vector` normal, int index, float distance),
         Values will all be None if no hit is found.

mathutils/geometry/__init__.pyi

@@ -1,3 +1,8 @@
+"""
+The Blender geometry module
+
+"""
+
 import typing
 import mathutils
 
@@ -7,7 +12,7 @@ def area_tri(
     v1: typing.Union[typing.Sequence[float], mathutils.Vector],
     v2: typing.Union[typing.Sequence[float], mathutils.Vector],
     v3: typing.Union[typing.Sequence[float], mathutils.Vector],
-):
+) -> float:
     """Returns the area size of the 2D or 3D triangle defined.
 
     :param v1: Point1
@@ -16,6 +21,7 @@ def area_tri(
     :type v2: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param v3: Point3
     :type v3: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :rtype: float
     """
 
     ...
@@ -50,12 +56,13 @@ def barycentric_transform(
 
     ...
 
-def box_fit_2d(points: list):
+def box_fit_2d(points: list) -> float:
     """Returns an angle that best fits the points to an axis aligned rectangle
 
     :param points: list of 2d points.
     :type points: list
     :return: angle
+    :rtype: float
     """
 
     ...
@@ -139,7 +146,7 @@ def distance_point_to_plane(
     pt: typing.Union[typing.Sequence[float], mathutils.Vector],
     plane_co: typing.Union[typing.Sequence[float], mathutils.Vector],
     plane_no: typing.Union[typing.Sequence[float], mathutils.Vector],
-):
+) -> float:
     """Returns the signed distance between a point and a plane    (negative when below the normal).
 
     :param pt: Point
@@ -148,6 +155,7 @@ def distance_point_to_plane(
     :type plane_co: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param plane_no: The direction the plane is facing
     :type plane_no: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :rtype: float
     """
 
     ...
@@ -157,7 +165,7 @@ def interpolate_bezier(
     handle1: typing.Union[typing.Sequence[float], mathutils.Vector],
     handle2: typing.Union[typing.Sequence[float], mathutils.Vector],
     knot2: typing.Union[typing.Sequence[float], mathutils.Vector],
-    resolution,
+    resolution: int,
 ):
     """Interpolate a bezier spline segment.
 
@@ -170,6 +178,7 @@ def interpolate_bezier(
     :param knot2: Second bezier spline point.
     :type knot2: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param resolution: Number of points to return.
+    :type resolution: int
     :return: The interpolated points
     """
 
@@ -331,7 +340,7 @@ def intersect_point_quad_2d(
     quad_p2: typing.Union[typing.Sequence[float], mathutils.Vector],
     quad_p3: typing.Union[typing.Sequence[float], mathutils.Vector],
     quad_p4: typing.Union[typing.Sequence[float], mathutils.Vector],
-):
+) -> int:
     """Takes 5 vectors (using only the x and y coordinates): one is the point and the next 4 define the quad,
     only the x and y are used from the vectors. Returns 1 if the point is within the quad, otherwise 0.
     Works only with convex quads without singular edges.
@@ -346,6 +355,7 @@ def intersect_point_quad_2d(
         :type quad_p3: typing.Union[typing.Sequence[float], mathutils.Vector]
         :param quad_p4: Fourth point of the quad
         :type quad_p4: typing.Union[typing.Sequence[float], mathutils.Vector]
+        :rtype: int
     """
 
     ...
@@ -376,7 +386,7 @@ def intersect_point_tri_2d(
     tri_p1: typing.Union[typing.Sequence[float], mathutils.Vector],
     tri_p2: typing.Union[typing.Sequence[float], mathutils.Vector],
     tri_p3: typing.Union[typing.Sequence[float], mathutils.Vector],
-):
+) -> int:
     """Takes 4 vectors (using only the x and y coordinates): one is the point and the next 3 define the triangle. Returns 1 if the point is within the triangle, otherwise 0.
 
     :param pt: Point
@@ -387,6 +397,7 @@ def intersect_point_tri_2d(
     :type tri_p2: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param tri_p3: Third point of the triangle
     :type tri_p3: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :rtype: int
     """
 
     ...
@@ -420,18 +431,20 @@ def intersect_ray_tri(
 
 def intersect_sphere_sphere_2d(
     p_a: typing.Union[typing.Sequence[float], mathutils.Vector],
-    radius_a,
+    radius_a: float,
     p_b: typing.Union[typing.Sequence[float], mathutils.Vector],
-    radius_b,
+    radius_b: float,
 ) -> typing.Tuple[mathutils.Vector]:
     """Returns 2 points on between intersecting circles.
 
     :param p_a: Center of the first circle
     :type p_a: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param radius_a: Radius of the first circle
+    :type radius_a: float
     :param p_b: Center of the second circle
     :type p_b: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param radius_b: Radius of the second circle
+    :type radius_b: float
     :rtype: typing.Tuple[mathutils.Vector]
     """
 
@@ -478,7 +491,7 @@ def volume_tetrahedron(
     v2: typing.Union[typing.Sequence[float], mathutils.Vector],
     v3: typing.Union[typing.Sequence[float], mathutils.Vector],
     v4: typing.Union[typing.Sequence[float], mathutils.Vector],
-):
+) -> float:
     """Return the volume formed by a tetrahedron (points can be in any order).
 
     :param v1: Point1
@@ -489,6 +502,7 @@ def volume_tetrahedron(
     :type v3: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param v4: Point4
     :type v4: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :rtype: float
     """
 
     ...

mathutils/interpolate/__init__.pyi

@@ -1,3 +1,8 @@
+"""
+The Blender interpolate module
+
+"""
+
 import typing
 
 GenericType = typing.TypeVar("GenericType")

mathutils/kdtree/__init__.pyi

@@ -1,3 +1,10 @@
+"""
+Generic 3-dimensional kd-tree to perform spatial searches.
+
+```../examples/mathutils.kdtree.py```
+
+"""
+
 import typing
 import mathutils
 
@@ -14,7 +21,7 @@ class KDTree:
         self,
         co: typing.Union[typing.Sequence[float], mathutils.Vector],
         filter: typing.Callable = None,
-    ) -> typing.Callable:
+    ) -> tuple:
         """Find nearest point to co.
 
         :param co: 3d coordinates.
@@ -26,36 +33,43 @@ class KDTree:
         """
         ...
 
-    def find_n(self, co: typing.Union[typing.Sequence[float], mathutils.Vector], n):
+    def find_n(
+        self, co: typing.Union[typing.Sequence[float], mathutils.Vector], n: int
+    ) -> list:
         """Find nearest n points to co.
 
         :param co: 3d coordinates.
         :type co: typing.Union[typing.Sequence[float], mathutils.Vector]
         :param n: Number of points to find.
+        :type n: int
         :return: Returns a list of tuples (`Vector`, index, distance).
         :rtype: list
         """
         ...
 
     def find_range(
-        self, co: typing.Union[typing.Sequence[float], mathutils.Vector], radius
-    ):
+        self, co: typing.Union[typing.Sequence[float], mathutils.Vector], radius: float
+    ) -> list:
         """Find all points within radius of co.
 
         :param co: 3d coordinates.
         :type co: typing.Union[typing.Sequence[float], mathutils.Vector]
         :param radius: Distance to search for points.
+        :type radius: float
         :return: Returns a list of tuples (`Vector`, index, distance).
         :rtype: list
         """
         ...
 
-    def insert(self, co: typing.Union[typing.Sequence[float], mathutils.Vector], index):
+    def insert(
+        self, co: typing.Union[typing.Sequence[float], mathutils.Vector], index: int
+    ):
         """Insert a point into the KDTree.
 
         :param co: Point 3d position.
         :type co: typing.Union[typing.Sequence[float], mathutils.Vector]
         :param index: The index of the point.
+        :type index: int
         """
         ...
 

mathutils/noise/__init__.pyi

@@ -1,14 +1,20 @@
+"""
+The Blender noise module
+
+"""
+
 import typing
 import mathutils
 
 GenericType = typing.TypeVar("GenericType")
 
-def cell(position: typing.Union[typing.Sequence[float], mathutils.Vector]):
+def cell(position: typing.Union[typing.Sequence[float], mathutils.Vector]) -> float:
     """Returns cell noise value at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :return: The cell noise value.
+    :rtype: float
     """
 
     ...
@@ -28,90 +34,109 @@ def cell_vector(
 
 def fractal(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H,
-    lacunarity,
-    octaves,
+    H: float,
+    lacunarity: float,
+    octaves: int,
     noise_basis: str = "PERLIN_ORIGINAL",
-):
+) -> float:
     """Returns the fractal Brownian motion (fBm) noise value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal increment factor.
+    :type H: float
     :param lacunarity: The gap between successive frequencies.
+    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
+    :type octaves: int
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The fractal Brownian motion noise value.
+    :rtype: float
     """
 
     ...
 
 def hetero_terrain(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H,
-    lacunarity,
-    octaves,
-    offset,
+    H: float,
+    lacunarity: float,
+    octaves: int,
+    offset: float,
     noise_basis: str = "PERLIN_ORIGINAL",
-):
+) -> float:
     """Returns the heterogeneous terrain value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal dimension of the roughest areas.
+    :type H: float
     :param lacunarity: The gap between successive frequencies.
+    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
+    :type octaves: int
     :param offset: The height of the terrain above 'sea level'.
+    :type offset: float
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The heterogeneous terrain value.
+    :rtype: float
     """
 
     ...
 
 def hybrid_multi_fractal(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H,
-    lacunarity,
-    octaves,
-    offset,
-    gain,
+    H: float,
+    lacunarity: float,
+    octaves: int,
+    offset: float,
+    gain: float,
     noise_basis: str = "PERLIN_ORIGINAL",
-):
+) -> float:
     """Returns hybrid multifractal value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal dimension of the roughest areas.
+    :type H: float
     :param lacunarity: The gap between successive frequencies.
+    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
+    :type octaves: int
     :param offset: The height of the terrain above 'sea level'.
+    :type offset: float
     :param gain: Scaling applied to the values.
+    :type gain: float
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The hybrid multifractal value.
+    :rtype: float
     """
 
     ...
 
 def multi_fractal(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H,
-    lacunarity,
-    octaves,
+    H: float,
+    lacunarity: float,
+    octaves: int,
     noise_basis: str = "PERLIN_ORIGINAL",
-):
+) -> float:
     """Returns multifractal noise value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal increment factor.
+    :type H: float
     :param lacunarity: The gap between successive frequencies.
+    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
+    :type octaves: int
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The multifractal noise value.
+    :rtype: float
     """
 
     ...
@@ -119,7 +144,7 @@ def multi_fractal(
 def noise(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
     noise_basis: str = "PERLIN_ORIGINAL",
-):
+) -> float:
     """Returns noise value from the noise basis at the position specified.
 
     :param position: The position to evaluate the selected noise function.
@@ -127,6 +152,7 @@ def noise(
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The noise value.
+    :rtype: float
     """
 
     ...
@@ -147,28 +173,31 @@ def noise_vector(
 
     ...
 
-def random():
+def random() -> float:
     """Returns a random number in the range [0, 1).
 
     :return: The random number.
+    :rtype: float
     """
 
     ...
 
-def random_unit_vector(size=3) -> mathutils.Vector:
+def random_unit_vector(size: int = 3) -> mathutils.Vector:
     """Returns a unit vector with random entries.
 
     :param size: The size of the vector to be produced, in the range [2, 4].
+    :type size: int
     :return: The random unit vector.
     :rtype: mathutils.Vector
     """
 
     ...
 
-def random_vector(size=3) -> mathutils.Vector:
+def random_vector(size: int = 3) -> mathutils.Vector:
     """Returns a vector with random entries in the range (-1, 1).
 
     :param size: The size of the vector to be produced.
+    :type size: int
     :return: The random vector.
     :rtype: mathutils.Vector
     """
@@ -177,81 +206,95 @@ def random_vector(size=3) -> mathutils.Vector:
 
 def ridged_multi_fractal(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    H,
-    lacunarity,
-    octaves,
-    offset,
-    gain,
+    H: float,
+    lacunarity: float,
+    octaves: int,
+    offset: float,
+    gain: float,
     noise_basis: str = "PERLIN_ORIGINAL",
-):
+) -> float:
     """Returns ridged multifractal value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param H: The fractal dimension of the roughest areas.
+    :type H: float
     :param lacunarity: The gap between successive frequencies.
+    :type lacunarity: float
     :param octaves: The number of different noise frequencies used.
+    :type octaves: int
     :param offset: The height of the terrain above 'sea level'.
+    :type offset: float
     :param gain: Scaling applied to the values.
+    :type gain: float
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :return: The ridged multifractal value.
+    :rtype: float
     """
 
     ...
 
-def seed_set(seed):
+def seed_set(seed: int):
     """Sets the random seed used for random_unit_vector, and random.
 
         :param seed: Seed used for the random generator.
     When seed is zero, the current time will be used instead.
+        :type seed: int
     """
 
     ...
 
 def turbulence(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    octaves,
+    octaves: int,
     hard: bool,
     noise_basis: str = "PERLIN_ORIGINAL",
-    amplitude_scale=0.5,
-    frequency_scale=2.0,
-):
+    amplitude_scale: float = 0.5,
+    frequency_scale: float = 2.0,
+) -> float:
     """Returns the turbulence value from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param octaves: The number of different noise frequencies used.
+    :type octaves: int
     :param hard: Specifies whether returned turbulence is hard (sharp transitions) or soft (smooth transitions).
     :type hard: bool
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :param amplitude_scale: The amplitude scaling factor.
+    :type amplitude_scale: float
     :param frequency_scale: The frequency scaling factor
+    :type frequency_scale: float
     :return: The turbulence value.
+    :rtype: float
     """
 
     ...
 
 def turbulence_vector(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    octaves,
+    octaves: int,
     hard: bool,
     noise_basis: str = "PERLIN_ORIGINAL",
-    amplitude_scale=0.5,
-    frequency_scale=2.0,
+    amplitude_scale: float = 0.5,
+    frequency_scale: float = 2.0,
 ) -> mathutils.Vector:
     """Returns the turbulence vector from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param octaves: The number of different noise frequencies used.
+    :type octaves: int
     :param hard: Specifies whether returned turbulence is hard (sharp transitions) or soft (smooth transitions).
     :type hard: bool
     :param noise_basis: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_basis: str
     :param amplitude_scale: The amplitude scaling factor.
+    :type amplitude_scale: float
     :param frequency_scale: The frequency scaling factor
+    :type frequency_scale: float
     :return: The turbulence vector.
     :rtype: mathutils.Vector
     """
@@ -260,20 +303,22 @@ def turbulence_vector(
 
 def variable_lacunarity(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
-    distortion,
+    distortion: float,
     noise_type1: str = "PERLIN_ORIGINAL",
     noise_type2: str = "PERLIN_ORIGINAL",
-):
+) -> float:
     """Returns variable lacunarity noise value, a distorted variety of noise, from noise type 1 distorted by noise type 2 at the specified position.
 
     :param position: The position to evaluate the selected noise function.
     :type position: typing.Union[typing.Sequence[float], mathutils.Vector]
     :param distortion: The amount of distortion.
+    :type distortion: float
     :param noise_type1: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_type1: str
     :param noise_type2: Enumerator in ['BLENDER', 'PERLIN_ORIGINAL', 'PERLIN_NEW', 'VORONOI_F1', 'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2F1', 'VORONOI_CRACKLE', 'CELLNOISE'].
     :type noise_type2: str
     :return: The variable lacunarity noise value.
+    :rtype: float
     """
 
     ...
@@ -281,7 +326,7 @@ def variable_lacunarity(
 def voronoi(
     position: typing.Union[typing.Sequence[float], mathutils.Vector],
     distance_metric: str = "DISTANCE",
-    exponent=2.5,
+    exponent: float = 2.5,
 ):
     """Returns a list of distances to the four closest features and their locations.
 
@@ -290,6 +335,7 @@ def voronoi(
     :param distance_metric: Enumerator in ['DISTANCE', 'DISTANCE_SQUARED', 'MANHATTAN', 'CHEBYCHEV', 'MINKOVSKY', 'MINKOVSKY_HALF', 'MINKOVSKY_FOUR'].
     :type distance_metric: str
     :param exponent: The exponent for Minkowski distance metric.
+    :type exponent: float
     :return: A list of distances to the four closest features and their locations.
     """