fake-bge-module 20250312__py3-none-any.whl → 20260203__py3-none-any.whl

{bl_i18n_utils → _bl_i18n_utils}/utils_rtl/__init__.pyi

@@ -1,14 +1,15 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
-def log2vis(msgs, settings):
+def log2vis(msgs, settings) -> None:
     """Globally mimics deprecated fribidi_log2vis.
     msgs should be an iterable of messages to RTL-process.
 
     """
 
-def protect_format_seq(msg):
+def protect_format_seq(msg) -> None:
     """Find some specific escaping/formatting sequences (like ", %s, etc.,
     and protect them from any modification!
 

_bl_i18n_utils/utils_spell_check/__init__.pyi

@@ -0,0 +1,22 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+
+class SpellChecker:
+    """A basic spell checker."""
+
+    uimsgs: typing.Any
+
+    def check(self, txt) -> None:
+        """
+
+        :param txt:
+        """
+
+    @classmethod
+    def split_words(cls, text) -> None:
+        """
+
+        :param text:
+        """

{bl_previews_utils → _bl_previews_utils}/__init__.pyi

@@ -1,4 +1,5 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import bl_previews_render as bl_previews_render

_bl_previews_utils/bl_previews_render/__init__.pyi

@@ -0,0 +1,14 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+
+def do_clear_previews(
+    do_objects, do_collections, do_scenes, do_data_intern
+) -> None: ...
+def do_previews(do_objects, do_collections, do_scenes, do_data_intern) -> None: ...
+def ids_nolib(bids) -> None: ...
+def ids_nolib_with_preview(bids) -> None: ...
+def main() -> None: ...
+def rna_backup_gen(data, include_props=None, exclude_props=None, root=()) -> None: ...
+def rna_backup_restore(data, backup) -> None: ...

{bl_rna_utils → _bl_rna_utils}/__init__.pyi

@@ -1,4 +1,5 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import data_path as data_path

{bl_rna_utils → _bl_rna_utils}/data_path/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 class _TokenizeDataPath:
     """Class to split up tokens of a data-path.Note that almost all access generates new objects with additional paths,
@@ -9,10 +10,10 @@ class _TokenizeDataPath:
 
     data_path: typing.Any
 
-def decompose_data_path(data_path):
+def decompose_data_path(data_path) -> None:
     """Return the components of a data path split into a list."""
 
-def property_definition_from_data_path(base, data_path):
+def property_definition_from_data_path(base, data_path) -> None:
     """Return an RNA property definition from an object and a data path.In Blender this is often used with context as the base and a
     path that it references, for example .space_data.lock_camera.
 

{bl_text_utils → _bl_text_utils}/__init__.pyi

@@ -1,4 +1,5 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import external_editor as external_editor

_bl_text_utils/external_editor/__init__.pyi

@@ -0,0 +1,6 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+
+def open_external_editor(filepath, line, column) -> None: ...

{bl_ui_utils → _bl_ui_utils}/__init__.pyi

@@ -1,4 +1,5 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import layout as layout

{bl_ui_utils → _bl_ui_utils}/layout/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
-def operator_context(layout, op_context):
+def operator_context(layout, op_context) -> None:
     """Context manager that temporarily overrides the operator context."""

_blendfile_header/__init__.pyi

@@ -0,0 +1,48 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+
+class BHead4:
+    """BHead4(code: bytes, len: int, old: int, SDNAnr: int, nr: int)"""
+
+class BlendFileHeader:
+    """BlendFileHeader represents the first 12-17 bytes of a blend file.It contains information about the hardware architecture, which is relevant
+    to the structure of the rest of the file.
+    """
+
+    def create_block_header_struct(self) -> None: ...
+
+class BlendHeaderError:
+    """Common base class for all non-exit exceptions."""
+
+    args: typing.Any
+
+class BlockHeader:
+    """A .blend file consists of a sequence of blocks whereby each block has a header.
+    This class can parse a header block in a specific .blend file.Note the binary representation of this header is different for different files.
+    This class provides a unified interface for these underlying representations.
+    """
+
+    addr_old: typing.Any
+    code: typing.Any
+    count: typing.Any
+    sdna_index: typing.Any
+    size: typing.Any
+
+class BlockHeaderStruct:
+    """BlockHeaderStruct(struct: _struct.Struct, type: Type[Union[_blendfile_header.BHead4, _blendfile_header.SmallBHead8, _blendfile_header.LargeBHead8]])"""
+
+    size: typing.Any
+
+    def parse(self, data) -> None:
+        """
+
+        :param data:
+        """
+
+class LargeBHead8:
+    """LargeBHead8(code: bytes, SDNAnr: int, old: int, len: int, nr: int)"""
+
+class SmallBHead8:
+    """SmallBHead8(code: bytes, len: int, old: int, SDNAnr: int, nr: int)"""

_bpy_internal/__init__.pyi

@@ -1,8 +1,12 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import addons as addons
+from . import assets as assets
+from . import disk_file_hash_service as disk_file_hash_service
 from . import extensions as extensions
-from . import freedesktop as freedesktop
+from . import filesystem as filesystem
 from . import grease_pencil as grease_pencil
+from . import platform as platform
 from . import system_info as system_info

_bpy_internal/addons/__init__.pyi

@@ -1,4 +1,5 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import cli as cli

_bpy_internal/addons/cli/__init__.pyi

@@ -1,5 +1,6 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
-def set_from_cli(addons_as_string): ...
+def set_from_cli(addons_as_string) -> None: ...

_bpy_internal/assets/__init__.pyi

@@ -0,0 +1,5 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+from . import remote_library_listing as remote_library_listing

_bpy_internal/assets/remote_library_listing/__init__.pyi

@@ -0,0 +1,5 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+from . import blender_asset_library_openapi as blender_asset_library_openapi

_bpy_internal/assets/remote_library_listing/blender_asset_library_openapi/__init__.pyi

@@ -0,0 +1,13 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+
+class AssetLibraryMeta:
+    """AssetLibraryMeta(api_versions: dict[str, str], name: str, contact: Contact)"""
+
+class Contact:
+    """Contact(name: str, url: str | None = None, email: str | None = None)"""
+
+    email: typing.Any
+    url: typing.Any

_bpy_internal/disk_file_hash_service/__init__.pyi

@@ -0,0 +1,19 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+from . import backend_sqlite as backend_sqlite
+from . import hash_service as hash_service
+from . import types as types
+
+def get_service(storage_path) -> None:
+    """Get a disk file hash service that stores its cache on the given path.Depending on the back-end (currently there is only the SQLite back-end, and
+    thus there is no choice in which one is used), the storage_path can be used
+    as directory or as file prefix. The SQLite back-end uses
+    {storage_path}_v{schema_version}.sqlite as storage.Once a DiskFileHashService is constructed, it is cached for future
+    invocations. These cached services are cleaned up when Blender loads another
+    file or when it exits.
+
+    """
+
+def on_blender_exit() -> None: ...

_bpy_internal/disk_file_hash_service/backend_sqlite/__init__.pyi

@@ -0,0 +1,48 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+
+class SQLiteBackend:
+    """DiskFileHashBackend implementation using SQLite as storage engine."""
+
+    db_conn_ro: typing.Any
+    db_conn_rw: typing.Any
+
+    def close(self) -> None:
+        """Close the database connection."""
+
+    def fetch_hash(self, filepath, hash_algorithm) -> None:
+        """Return the cached hash info of a given file.Returns a tuple (hexdigest, file size in bytes, last file mtime).
+
+        :param filepath:
+        :param hash_algorithm:
+        """
+
+    def mark_hash_as_fresh(self, filepath, hash_algorithm) -> None:
+        """Store that the hash is still considered fresh.See remove_older_than().
+
+        :param filepath:
+        :param hash_algorithm:
+        """
+
+    def open(self) -> None:
+        """Prepare the back-end for use.Create the directory structure & database file, and ensure the schema is as expected."""
+
+    def remove_older_than(self, *, days) -> None:
+        """Remove all hash entries that are older than this many days.When this removes all known hashes for a file, the file entry itself is
+        also removed.
+
+                :param days:
+        """
+
+    def store_hash(
+        self, filepath, hash_algorithm, hash_info, pre_write_callback=None
+    ) -> None:
+        """Store a pre-computed hash for the given file path. The path has to exist.
+
+        :param filepath:
+        :param hash_algorithm:
+        :param hash_info:
+        :param pre_write_callback:
+        """

_bpy_internal/disk_file_hash_service/hash_service/__init__.pyi

@@ -0,0 +1,64 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+
+class DiskFileHashService:
+    def close(self) -> None:
+        """Close the service."""
+
+    def file_matches(self, filepath, hash_algorithm, hexhash, size_in_byes) -> None:
+        """Check the file on disk, to see if it matches the given properties.
+
+        :param filepath:
+        :param hash_algorithm:
+        :param hexhash:
+        :param size_in_byes:
+        """
+
+    def get_hash(self, filepath, hash_algorithm) -> None:
+        """Return the hash of a file on disk.
+
+        :param filepath:
+        :param hash_algorithm:
+        """
+
+    def open(self) -> None:
+        """Prepare the service for use."""
+
+    def store_hash(
+        self, filepath, hash_algorithm, hash_info, pre_write_callback=None
+    ) -> None:
+        """Store a pre-computed hash for the given file path.
+
+                :param filepath: the file whose hash should be stored. It does not have
+        to exist on disk yet at the moment of calling this function. If the
+        file does not exist, a pre_write_callback function should be given
+        that ensures the file does exist after it has been called.
+                :param hash_algorithm:
+                :param hash_info: the files hash, size in bytes, and last-modified
+        timestamp. When pre_write_callback is not None, the caller is
+        trusted to provide the correct information. Otherwise the file size
+        and last-modification timestamp are checked against the file on
+        disk. If they mis-match, a ValueError is raised.
+                :param pre_write_callback: if given, the function is called after any
+        lock on the storage back-end has been obtained, and before it is
+        updated. Any exception raised by this callback will abort the
+        storage of the hash.
+
+        This callback function can be used to implement the following:
+
+        Download a file to a temp location.
+
+        Compute its hash while downloading.
+
+        After downloading is complete, get the file size & modification time.
+
+        Store the hash.
+
+        In the pre-write callback function, move the file to its final location.
+
+        The Disk File Hashing Service unlocks the back-end.
+
+        This ensures the hash and file on disk are consistent.
+        """

_bpy_internal/disk_file_hash_service/types/__init__.pyi

@@ -0,0 +1,53 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+
+class DiskFileHashBackend:
+    """Base class for protocol classes.Protocol classes are defined as:Such classes are primarily used with static type checkers that recognize
+    structural subtyping (static duck-typing).For example:See PEP 544 for details. Protocol classes decorated with
+    @typing.runtime_checkable act as simple-minded runtime protocols that check
+    only the presence of given attributes, ignoring their type signatures.
+    Protocol classes can be generic, they are defined as:
+    """
+
+    def close(self) -> None:
+        """Close the back-end.After calling this, the back-end is not expected to work any more."""
+
+    def fetch_hash(self, filepath, hash_algorithm) -> None:
+        """Return the cached hash info of a given file.If no info is cached for this path/algorithm combo, returns None.
+
+        :param filepath:
+        :param hash_algorithm:
+        """
+
+    def mark_hash_as_fresh(self, filepath, hash_algorithm) -> None:
+        """Store that the hash is still considered fresh.See remove_older_than().
+
+        :param filepath:
+        :param hash_algorithm:
+        """
+
+    def open(self) -> None:
+        """Prepare the back-end for use."""
+
+    def remove_older_than(self, *, days) -> None:
+        """Remove all hash entries that are older than this many days.When this removes all known hashes for a file, the file entry itself is
+        also removed.
+
+                :param days:
+        """
+
+    def store_hash(
+        self, filepath, hash_algorithm, hash_info, pre_write_callback=None
+    ) -> None:
+        """Store a pre-computed hash for the given file path.See DiskFileHashService.store_hash() for an explanation of the parameters.
+
+        :param filepath:
+        :param hash_algorithm:
+        :param hash_info:
+        :param pre_write_callback:
+        """
+
+class FileHashInfo:
+    """FileHashInfo(hexhash: str, file_size_bytes: int, file_stat_mtime: float)"""

_bpy_internal/extensions/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import junction_module as junction_module
 from . import stale_file_manager as stale_file_manager
 from . import wheel_manager as wheel_manager

_bpy_internal/extensions/junction_module/__init__.pyi

@@ -1,40 +1,41 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 class JunctionModuleHandle:
-    def register_module(self):
+    def register_module(self) -> None:
         """Register the base module in sys.modules."""
 
-    def register_submodule(self, submodule_name, dirpath):
+    def register_submodule(self, submodule_name, dirpath) -> None:
         """
 
         :param submodule_name:
         :param dirpath:
         """
 
-    def rename_directory(self, submodule_name, dirpath):
+    def rename_directory(self, submodule_name, dirpath) -> None:
         """
 
         :param submodule_name:
         :param dirpath:
         """
 
-    def rename_submodule(self, submodule_name_src, submodule_name_dst):
+    def rename_submodule(self, submodule_name_src, submodule_name_dst) -> None:
         """
 
         :param submodule_name_src:
         :param submodule_name_dst:
         """
 
-    def submodule_items(self): ...
-    def unregister_module(self):
+    def submodule_items(self) -> None: ...
+    def unregister_module(self) -> None:
         """Unregister the base module in sys.modules.
         Keep everything except the modules name (allowing re-registration).
 
         """
 
-    def unregister_submodule(self, submodule_name):
+    def unregister_submodule(self, submodule_name) -> None:
         """
 
         :param submodule_name:

_bpy_internal/extensions/stale_file_manager/__init__.pyi

@@ -1,37 +1,38 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 class StaleFiles:
-    def filepath_add(self, path_abs, *, rename):
+    def filepath_add(self, path_abs, *, rename) -> None:
         """
 
         :param path_abs:
         :param rename:
         """
 
-    def is_empty(self): ...
-    def is_modified(self): ...
-    def state_load(self, *, check_exists):
+    def is_empty(self) -> None: ...
+    def is_modified(self) -> None: ...
+    def state_load(self, *, check_exists) -> None:
         """
 
         :param check_exists:
         """
 
-    def state_load_add_and_store(self, *, paths):
+    def state_load_add_and_store(self, *, paths) -> None:
         """
 
         :param paths:
         """
 
-    def state_load_remove_and_store(self, *, paths):
+    def state_load_remove_and_store(self, *, paths) -> None:
         """
 
         :param paths:
         """
 
-    def state_remove_all(self): ...
-    def state_store(self, *, check_exists):
+    def state_remove_all(self) -> None: ...
+    def state_store(self, *, check_exists) -> None:
         """
 
         :param check_exists:

_bpy_internal/extensions/wheel_manager/__init__.pyi

@@ -1,20 +1,21 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 def apply_action(
     *, local_dir, local_dir_site_packages, wheel_list, error_fn, remove_error_fn, debug
-): ...
-def wheel_list_deduplicate_as_skip_set(wheel_list):
+) -> None: ...
+def wheel_list_deduplicate_as_skip_set(wheel_list) -> None:
     """Return all wheel paths to skip."""
 
-def wheel_version_from_filename_for_cmp(filename):
+def wheel_version_from_filename_for_cmp(filename) -> None:
     """Extract the version number for comparison.
     Note that this only handled the first 3 numbers,
     the trailing text is compared as a string which is not technically correct
     however this is not a priority to support since scripts should only be including stable releases,
     so comparing the first 3 numbers is sufficient. The trailing string is just a tie breaker in the
-    unlikely event it differs.If supporting the full spec, comparing: "1.1.dev6" with "1.1.6rc6" for e.g.
-    we could support this doesn't seem especially important as extensions should use major releases.
+    unlikely event it differs.If supporting the full spec, comparing: "1.1.dev6" with "1.1.6rc6" for example
+    we could support this doesnt seem especially important as extensions should use major releases.
 
     """

{bl_i18n_utils/utils_languages_menu → _bpy_internal/filesystem}/__init__.pyi

@@ -1,5 +1,5 @@
 import typing
 import collections.abc
 import typing_extensions
-
-def gen_menu_file(stats, settings): ...
+import numpy.typing as npt
+from . import locking as locking

_bpy_internal/filesystem/locking/__init__.pyi

@@ -0,0 +1,28 @@
+import typing
+import collections.abc
+import typing_extensions
+import numpy.typing as npt
+
+class MutexAcquisitionError:
+    """Raised when mutex_lock_and_open_with_retry() cannot obtain a lock."""
+
+    args: typing.Any
+
+def mutex_lock_and_open(file_path, mode) -> None:
+    """Obtain an exclusive lock on a file.Create a file on disk, and immediately lock it for exclusive use by this
+    process.
+
+        :return: If the file was opened & locked successfully, a tuple (file,
+    unlocker) is returned. Otherwise returns None. The caller should call
+    unlocker(file) to unlock the mutex.
+    """
+
+def mutex_lock_and_open_with_retry(
+    file_path, mode, *, max_tries, wait_time_sec
+) -> None:
+    """Obtain an exclusive lock on a file, retrying when that fails.See mutex_lock_and_open() for the lock semantics, and the first two parameters.
+
+        :param max_tries: number of times the code attempts to acquire the lock.
+        :return: A tuple (file, unlocker) is returned. The caller should call
+    unlocker(file) to unlock the mutex.
+    """

_bpy_internal/grease_pencil/__init__.pyi

@@ -1,4 +1,5 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import stroke as stroke