fake-bpy-module 20250612__py3-none-any.whl → 20260118__py3-none-any.whl

mathutils/interpolate/__init__.pyi

@@ -1,5 +1,5 @@
 """
-The Blender interpolate module
+The Blender interpolate module.
 
 """
 
@@ -9,12 +9,13 @@ import typing_extensions
 import numpy.typing as npt
 
 def poly_3d_calc(
-    veclist: collections.abc.Sequence[collections.abc.Sequence[float]], pt
+    veclist: collections.abc.Sequence[collections.abc.Sequence[float]],
+    pt: collections.abc.Sequence[float],
+    /,
 ) -> list[float]:
     """Calculate barycentric weights for a point on a polygon.
 
     :param veclist: Sequence of 3D positions.
-    :type veclist: collections.abc.Sequence[collections.abc.Sequence[float]]
-    :param pt: 2D or 3D position.   :type pt: Sequence[float]   :return: list of per-vector weights.
-    :rtype: list[float]
+    :param pt: 2D or 3D position.
+    :return: list of per-vector weights.
     """

mathutils/kdtree/__init__.pyi

@@ -20,16 +20,14 @@ class KDTree:
     def find(
         self,
         co: collections.abc.Sequence[float],
+        *,
         filter: collections.abc.Callable[int, bool] | None = None,
     ) -> tuple[mathutils.Vector, int, float]:
         """Find nearest point to co.
 
         :param co: 3D coordinates.
-        :type co: collections.abc.Sequence[float]
         :param filter: function which takes an index and returns True for indices to include in the search.
-        :type filter: collections.abc.Callable[int, bool] | None
         :return: Returns (position, index, distance).
-        :rtype: tuple[mathutils.Vector, int, float]
         """
 
     def find_n(
@@ -38,11 +36,8 @@ class KDTree:
         """Find nearest n points to co.
 
         :param co: 3D coordinates.
-        :type co: collections.abc.Sequence[float]
         :param n: Number of points to find.
-        :type n: int
         :return: Returns a list of tuples (position, index, distance).
-        :rtype: list[tuple[mathutils.Vector, int, float]]
         """
 
     def find_range(
@@ -51,20 +46,15 @@ class KDTree:
         """Find all points within radius of co.
 
         :param co: 3D coordinates.
-        :type co: collections.abc.Sequence[float]
         :param radius: Distance to search for points.
-        :type radius: float
         :return: Returns a list of tuples (position, index, distance).
-        :rtype: list[tuple[mathutils.Vector, int, float]]
         """
 
     def insert(self, co: collections.abc.Sequence[float], index: int) -> None:
         """Insert a point into the KDTree.
 
         :param co: Point 3d position.
-        :type co: collections.abc.Sequence[float]
         :param index: The index of the point.
-        :type index: int
         """
 
     def __init__(self, size) -> None:

mathutils/noise/__init__.pyi

@@ -1,5 +1,5 @@
 """
-The Blender noise module
+The Blender noise module.
 
 """
 
@@ -9,24 +9,24 @@ import typing_extensions
 import numpy.typing as npt
 import mathutils
 
-def cell(position: collections.abc.Sequence[float] | mathutils.Vector) -> float:
+def cell(
+    position: collections.abc.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: collections.abc.Sequence[float] | mathutils.Vector
     :return: The cell noise value.
-    :rtype: float
     """
 
 def cell_vector(
     position: collections.abc.Sequence[float] | mathutils.Vector,
+    /,
 ) -> mathutils.Vector:
     """Returns cell noise vector at the specified position.
 
     :param position: The position to evaluate the selected noise function.
-    :type position: collections.abc.Sequence[float] | mathutils.Vector
     :return: The cell noise vector.
-    :rtype: mathutils.Vector
     """
 
 def fractal(
@@ -34,22 +34,18 @@ def fractal(
     H: float,
     lacunarity: float,
     octaves: int,
-    noise_basis: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_basis="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: collections.abc.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
+    :param noise_basis: A noise basis string.
     :return: The fractal Brownian motion noise value.
-    :rtype: float
     """
 
 def hetero_terrain(
@@ -58,24 +54,19 @@ def hetero_terrain(
     lacunarity: float,
     octaves: int,
     offset: float,
-    noise_basis: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_basis="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: collections.abc.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
+    :param offset: The height of the terrain above sea level.
+    :param noise_basis: A noise basis string.
     :return: The heterogeneous terrain value.
-    :rtype: float
     """
 
 def hybrid_multi_fractal(
@@ -85,26 +76,20 @@ def hybrid_multi_fractal(
     octaves: int,
     offset: float,
     gain: float,
-    noise_basis: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_basis="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: collections.abc.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 offset: The height of the terrain above sea level.
     :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
+    :param noise_basis: A noise basis string.
     :return: The hybrid multifractal value.
-    :rtype: float
     """
 
 def multi_fractal(
@@ -112,75 +97,64 @@ def multi_fractal(
     H: float,
     lacunarity: float,
     octaves: int,
-    noise_basis: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_basis="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: collections.abc.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
+    :param noise_basis: A noise basis string.
     :return: The multifractal noise value.
-    :rtype: float
     """
 
 def noise(
     position: collections.abc.Sequence[float] | mathutils.Vector,
-    noise_basis: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_basis="PERLIN_ORIGINAL",
 ) -> float:
     """Returns noise value from the noise basis at the position specified.
 
     :param position: The position to evaluate the selected noise function.
-    :type position: collections.abc.Sequence[float] | mathutils.Vector
-    :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 noise_basis: A noise basis string.
     :return: The noise value.
-    :rtype: float
     """
 
 def noise_vector(
     position: collections.abc.Sequence[float] | mathutils.Vector,
-    noise_basis: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_basis="PERLIN_ORIGINAL",
 ) -> mathutils.Vector:
     """Returns the noise vector from the noise basis at the specified position.
 
     :param position: The position to evaluate the selected noise function.
-    :type position: collections.abc.Sequence[float] | mathutils.Vector
-    :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 noise_basis: A noise basis string.
     :return: The noise vector.
-    :rtype: mathutils.Vector
     """
 
 def random() -> float:
     """Returns a random number in the range [0, 1).
 
     :return: The random number.
-    :rtype: float
     """
 
-def random_unit_vector(size: int = 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: int = 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
     """
 
 def ridged_multi_fractal(
@@ -190,121 +164,102 @@ def ridged_multi_fractal(
     octaves: int,
     offset: float,
     gain: float,
-    noise_basis: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_basis="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: collections.abc.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 offset: The height of the terrain above sea level.
     :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
+    :param noise_basis: A noise basis string.
     :return: The ridged multifractal value.
-    :rtype: float
     """
 
-def seed_set(seed: int) -> None:
+def seed_set(
+    seed: int,
+    /,
+) -> None:
     """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: collections.abc.Sequence[float] | mathutils.Vector,
     octaves: int,
     hard: bool,
-    noise_basis: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_basis="PERLIN_ORIGINAL",
     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: collections.abc.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 noise_basis: A noise basis string.
     :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: collections.abc.Sequence[float] | mathutils.Vector,
     octaves: int,
     hard: bool,
-    noise_basis: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_basis="PERLIN_ORIGINAL",
     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: collections.abc.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 noise_basis: A noise basis string.
     :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
     """
 
 def variable_lacunarity(
     position: collections.abc.Sequence[float] | mathutils.Vector,
     distortion: float,
-    noise_type1: str = "PERLIN_ORIGINAL",
-    noise_type2: str = "PERLIN_ORIGINAL",
+    /,
+    *,
+    noise_type1="PERLIN_ORIGINAL",
+    noise_type2="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: collections.abc.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
+    :param noise_type1: A noise type string.
+    :param noise_type2: A noise type string.
     :return: The variable lacunarity noise value.
-    :rtype: float
     """
 
 def voronoi(
     position: collections.abc.Sequence[float] | mathutils.Vector,
-    distance_metric: str = "DISTANCE",
+    /,
+    *,
+    distance_metric="DISTANCE",
     exponent: float = 2.5,
 ) -> list[list[float] | list[mathutils.Vector]]:
     """Returns a list of distances to the four closest features and their locations.
 
     :param position: The position to evaluate the selected noise function.
-    :type position: collections.abc.Sequence[float] | mathutils.Vector
-    :param distance_metric: Enumerator in ['DISTANCE', 'DISTANCE_SQUARED', 'MANHATTAN', 'CHEBYCHEV', 'MINKOVSKY', 'MINKOVSKY_HALF', 'MINKOVSKY_FOUR'].
-    :type distance_metric: str
+    :param distance_metric: A distance metric string.
     :param exponent: The exponent for Minkowski distance metric.
-    :type exponent: float
     :return: A list of distances to the four closest features and their locations.
-    :rtype: list[list[float] | list[mathutils.Vector]]
     """

rna_prop_ui/__init__.pyi

@@ -5,7 +5,7 @@ import numpy.typing as npt
 
 class PropertyPanel:
     """The subclass should have its own poll function
-    and the variable '_context_path' MUST be set.
+    and the variable _context_path MUST be set.
     """
 
     bl_label: typing.Any