fake-bpy-module 20250828__py3-none-any.whl → 20260119__py3-none-any.whl

{bl_console_utils → _bl_console_utils}/autocomplete/complete_calltip/__init__.pyi

@@ -9,13 +9,9 @@ def complete(
     """Complete callable with call-tip.
 
     :param line: incomplete text line
-    :type line: str
     :param cursor: current character position
-    :type cursor: int
     :param namespace: namespace
-    :type namespace: dict[str, typing.Any]
     :return: (matches, world, scrollback)
-    :rtype: tuple[str, str, str]
     """
 
 def get_argspec(
@@ -24,36 +20,27 @@ def get_argspec(
     """Get argument specifications.
 
     :param strip_self: strip self from argspec
-    :type strip_self: bool
     :param doc: doc string of func (optional)
-    :type doc: str | None
     :param source: source code of func (optional)
-    :type source: str | None
     :return: argument specification
-    :rtype: str
     """
 
 def get_doc(obj) -> str:
     """Get the doc string or comments for an object.
 
     :return: doc string
-    :rtype: str
     """
 
 def reduce_newlines(text: str) -> str:
     """Reduces multiple newlines to a single newline.
 
     :param text: text with multiple newlines
-    :type text: str
     :return: text with single newlines
-    :rtype: str
     """
 
 def reduce_spaces(text: str) -> str:
     """Reduces multiple white-spaces to a single space.
 
     :param text: text with multiple spaces
-    :type text: str
     :return: text with single spaces
-    :rtype: str
     """

{bl_console_utils → _bl_console_utils}/autocomplete/complete_import/__init__.pyi

@@ -10,9 +10,7 @@ def complete(line: str) -> list[str]:
 
     import xml.d
     from xml.dom import
-        :type line: str
         :return: list of completion possibilities
-        :rtype: list[str]
     """
 
 def get_root_modules() -> list:
@@ -20,7 +18,6 @@ def get_root_modules() -> list:
     folders of the python-path.
 
         :return: modules
-        :rtype: list
     """
 
 def module_list(path: str) -> list:
@@ -28,7 +25,5 @@ def module_list(path: str) -> list:
     the given folder.
 
         :param path: folder path
-        :type path: str
         :return: modules
-        :rtype: list
     """

{bl_console_utils → _bl_console_utils}/autocomplete/complete_namespace/__init__.pyi

@@ -8,13 +8,9 @@ def complete(word: str, namespace: dict, *, private: bool = True) -> list[str]:
     module. Also supports index or key access [].
 
         :param word: word to be completed
-        :type word: str
         :param namespace: namespace
-        :type namespace: dict
         :param private: whether private attribute/methods should be returned
-        :type private: bool
         :return: completion matches
-        :rtype: list[str]
     """
 
 def complete_indices(
@@ -23,25 +19,18 @@ def complete_indices(
     """Complete a list or dictionary with its indices:
 
     :param word: word to be completed
-    :type word: str
     :param namespace: namespace
-    :type namespace: dict
     :param obj: object evaluated from base
     :param base: sub-string which can be evaluated into an object.
-    :type base: str | None
     :return: completion matches
-    :rtype: list[str]
     """
 
 def complete_names(word: str, namespace: dict[str, typing.Any]) -> list[str]:
     """Complete variable names or attributes
 
     :param word: word to be completed
-    :type word: str
     :param namespace: namespace
-    :type namespace: dict[str, typing.Any]
     :return: completion matches
-    :rtype: list[str]
     """
 
 def is_dict(obj) -> None:

{bl_console_utils → _bl_console_utils}/autocomplete/intellisense/__init__.pyi

@@ -9,15 +9,10 @@ def complete(
     """Returns a list of possible completions:
 
     :param line: incomplete text line
-    :type line: str
     :param cursor: current character position
-    :type cursor: int
     :param namespace: namespace
-    :type namespace: dict
     :param private: whether private variables should be listed
-    :type private: bool
     :return: list of completions, word
-    :rtype: tuple[list[str], str]
     """
 
 def expand(
@@ -27,13 +22,8 @@ def expand(
     e.g. when Ctrl+Space is clicked.
 
         :param line: incomplete text line
-        :type line: str
         :param cursor: current character position
-        :type cursor: int
         :param namespace: namespace
-        :type namespace: dict[str, typing.Any]
         :param private: whether private variables should be listed
-        :type private: bool
         :return: current expanded line, updated cursor position and scrollback
-        :rtype: int | str
     """

{bl_i18n_utils → _bl_i18n_utils}/__init__.pyi

@@ -9,3 +9,4 @@ from . import utils as utils
 from . import utils_cli as utils_cli
 from . import utils_languages_menu as utils_languages_menu
 from . import utils_rtl as utils_rtl
+from . import utils_spell_check as utils_spell_check

{bl_i18n_utils → _bl_i18n_utils}/bl_extract_messages/__init__.pyi

@@ -11,6 +11,7 @@ def dump_addon_messages(addon_module_name, do_checks, settings) -> None: ...
 def dump_asset_messages(msgs, reports, settings) -> None: ...
 def dump_extension_metadata(msgs, reports, settings) -> None: ...
 def dump_messages(do_messages, do_checks, settings) -> None: ...
+def dump_ocio_config(msgs, reports, settings) -> None: ...
 def dump_preset_messages(msgs, reports, settings) -> None: ...
 def dump_py_messages(msgs, reports, addons, settings, addons_only=False) -> None: ...
 def dump_py_messages_from_files(msgs, reports, files, settings) -> None: ...

{bl_i18n_utils → _bl_i18n_utils}/settings/__init__.pyi

@@ -44,3 +44,5 @@ class I18nSettings:
 
     def to_dict(self) -> None: ...
     def to_json(self) -> None: ...
+
+class PyGettextKeyword: ...

_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_ui_utils → _bl_ui_utils}/__init__.pyi

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

_bpy_internal/__init__.pyi

@@ -4,7 +4,9 @@ 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/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/filesystem/__init__.pyi

@@ -0,0 +1,5 @@
+import typing
+import collections.abc
+import typing_extensions
+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 succesfully, 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/platform/__init__.pyi

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