@volter/blender-engine 0.1.148 → 0.1.150

package/browser/addons/vrm/common/deep.py

@@ -0,0 +1,162 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+import difflib
+import math
+from collections.abc import Mapping
+from json import dumps as json_dumps
+from types import MappingProxyType
+
+from . import convert
+from .convert import Json, JsonView
+from .logger import get_logger
+
+_logger = get_logger(__name__)
+
+
+def make_json(v: object) -> Json:
+    if v is None:
+        return None
+    if isinstance(v, int):
+        return v
+    if isinstance(v, float):
+        if not math.isfinite(v):
+            _logger.warning("%s %s is non-finite value", v, type(v))
+            return 0.0
+        return v
+    if isinstance(v, bool):
+        return v
+    if isinstance(v, str):
+        return v
+
+    mapping = convert.mapping_or_none(v)
+    if mapping is not None:
+        dict_result: dict[str, Json] = {}
+        for key, value in mapping.items():
+            if isinstance(key, str):
+                dict_result[key] = make_json(value)
+                continue
+            _logger.warning("%s %s is unrecognized type for dict key", key, type(key))
+        return dict_result
+
+    iterator = convert.iterator_or_none(v)
+    if iterator is not None:
+        return [make_json(x) for x in iterator]
+
+    _logger.warning("%s %s is unrecognized type", v, type(v))
+    return None
+
+
+def make_json_view(v: object) -> JsonView:
+    json = make_json(v)
+    if isinstance(json, dict):
+        return MappingProxyType(
+            {key: make_json_view(value) for key, value in json.items()}
+        )
+    if isinstance(json, list):
+        return tuple(make_json_view(x) for x in json)
+    return json
+
+
+def make_json_dict(v: Mapping[str, object]) -> dict[str, Json]:
+    return {key: make_json(value) for key, value in v.items()}
+
+
+def diff(
+    left: Json,
+    right: Json,
+    float_tolerance: float = 0,
+    path: str = "",
+) -> list[str]:
+    if isinstance(left, list):
+        if not isinstance(right, list):
+            return [f"{path}: left is list but right is {type(right)}"]
+        if len(left) != len(right):
+            result = [
+                f"{path}: left length is {len(left)} but right length is {len(right)}"
+            ]
+
+            right_json_str = json_dumps(right, indent=4, sort_keys=True)
+            right_json_lines = right_json_str.splitlines(keepends=True)
+            left_json_str = json_dumps(left, indent=4, sort_keys=True)
+            left_json_lines = left_json_str.splitlines(keepends=True)
+
+            if len(right_json_lines) > 1000 or len(left_json_lines) > 1000:
+                return result
+
+            unified_diff = [
+                line.rstrip()
+                for line in difflib.unified_diff(
+                    right_json_lines,
+                    left_json_lines,
+                    f"{path}/right",
+                    f"{path}/left",
+                )
+            ]
+            if len(unified_diff) > 1000:
+                return result
+            return result + unified_diff
+        diffs: list[str] = []
+        for i, (left_child, right_child) in enumerate(zip(left, right)):
+            diffs.extend(diff(left_child, right_child, float_tolerance, f"{path}[{i}]"))
+        return diffs
+
+    if isinstance(left, dict):
+        if not isinstance(right, dict):
+            return [f"{path}: left is dict but right is {type(right)}"]
+        diffs = []
+        for key in sorted(left.keys() | right.keys()):
+            if key not in left:
+                diffs.append(f'{path}: {key} not in left. right["{key}"]={right[key]}')
+                continue
+            if key not in right:
+                diffs.append(f'{path}: {key} not in right, left["{key}"]={left[key]}')
+                continue
+            diffs.extend(
+                diff(left[key], right[key], float_tolerance, f'{path}["{key}"]')
+            )
+        return diffs
+
+    if isinstance(left, bool):
+        if not isinstance(right, bool):
+            return [f"{path}: left is bool but right is {type(right)}"]
+        if left != right:
+            return [f"{path}: left is {left} but right is {right}"]
+        return []
+
+    if isinstance(left, str):
+        if not isinstance(right, str):
+            return [f"{path}: left is str but right is {type(right)}"]
+        if left != right:
+            return [f'{path}: left is "{left}" but right is "{right}"']
+        return []
+
+    if isinstance(left, int) and isinstance(right, int):
+        if left != right:
+            return [f"{path}: left is {left} but right is {right}"]
+        return []
+
+    if isinstance(left, (int, float)) and isinstance(right, (int, float)):
+        if (isinstance(left, float) and not math.isfinite(left)) or (
+            isinstance(right, float) and not math.isfinite(right)
+        ):
+            return [
+                f"{path}: left is {left}"
+                + f" but right is {right}, They are not comparable numbers"
+            ]
+
+        error = math.fabs(float(left) - float(right))
+        if error > float_tolerance:
+            return [
+                f"{path}: left is {float(left):20.17f}"
+                + f" but right is {float(right):20.17f}, error={error:19.17f}"
+            ]
+        return []
+
+    if left is None:
+        if right is None:
+            return []
+        return [f"{path}: left is None but right is {type(right)}"]
+    if right is None:
+        return [f"{path}: left is {type(left)} but right is None"]
+
+    message = f"{path}: unexpected type left={type(left)} right={type(right)}"
+    raise ValueError(message)

package/browser/addons/vrm/common/error_dialog.py

@@ -0,0 +1,274 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+
+import contextlib
+import datetime as dt
+import getpass
+import platform
+import sys
+import sysconfig
+from collections.abc import Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar, Union
+
+import bpy
+from bpy.props import CollectionProperty, IntProperty, StringProperty
+from bpy.types import (
+    Context,
+    Event,
+    Operator,
+    PropertyGroup,
+    UILayout,
+    UIList,
+)
+from bpy_extras.io_utils import ExportHelper
+
+from ..common import convert, ops
+from ..common.logger import get_logger
+from ..common.version import get_addon_version
+from ..editor.ops import VRM_OT_open_url_in_web_browser, layout_operator
+from ..editor.property_group import CollectionPropertyProtocol
+from ..external import io_scene_gltf2_support
+
+_logger = get_logger(__name__)
+
+
+def show_error_dialog(
+    title: str,
+    lines: Union[str, Sequence[str]],
+    *,
+    append_environment: bool = True,
+) -> set[str]:
+    if isinstance(lines, str):
+        lines = [line.rstrip() for line in lines.splitlines()]
+        while lines and not lines[0].strip():
+            del lines[0]
+        while lines and not lines[-1].strip():
+            del lines[-1]
+    else:
+        lines = list(lines)
+    if not lines:
+        return {"CANCELLED"}
+    if append_environment:
+        if lines:
+            lines[0] = f"Python: {lines[0]}"
+        lines = io_scene_gltf2_support.read_addon_diagnostics() + lines
+
+        os_name = None
+        platform_system, _, _ = platform.system_alias(
+            platform.system(), platform.release(), platform.version()
+        )
+        if sys.version_info >= (3, 10) and platform_system not in {"Windows", "Darwin"}:
+            # https://github.com/python/cpython/blob/v3.10.18/Doc/library/platform.rst?plain=1#L271-L272
+            with contextlib.suppress(OSError):
+                os_name = platform.freedesktop_os_release().get("PRETTY_NAME")
+
+        if not os_name:
+            os_name = platform_system
+
+        python_version = (
+            platform.python_implementation()
+            + " "
+            + ".".join(map(str, sys.version_info[:3]))
+        )
+        runtime_platform = os_name + " " + platform.machine()
+        build_platform = sysconfig.get_platform()
+        lines.insert(
+            0,
+            "Environment: Blender {} / VRM Add-on {} / {} / {} ({})".format(
+                bpy.app.version_string,
+                ".".join(map(str, get_addon_version())),
+                python_version,
+                runtime_platform,
+                build_platform,
+            ),
+        )
+    return ops.wm.vrm_error_dialog(
+        "INVOKE_DEFAULT",
+        title=title,
+        lines=[
+            {
+                "name": f"error_line_{i}",
+                "line": _mask_private_string(line),
+            }
+            for i, line in enumerate(lines)
+        ],
+    )
+
+
+def _mask_private_string(message: str) -> str:
+    script_path = Path(__file__).parent.parent.parent.parent.parent
+    if len(script_path.parts) > 3:
+        message = message.replace(str(script_path), "<script path>")
+
+    message = message.replace(str(Path.home()), "<home path>")
+    message = message.replace(getpass.getuser(), "<user name>")
+    binary_path = bpy.app.binary_path
+    if binary_path:
+        binary_folder_path = Path(binary_path).parent
+        message = message.replace(str(binary_folder_path), "<bin folder path>")
+    return message
+
+
+class VrmErrorDialogMessageLine(PropertyGroup):
+    line: StringProperty()  # type: ignore[valid-type]
+
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        line: str  # type: ignore[no-redef]
+
+
+class VRM_UL_vrm_error_dialog_message(UIList):
+    bl_idname = "VRM_UL_vrm_error_dialog_message"
+
+    def filter_items(
+        self,
+        _context: Context,
+        data: object,
+        propname: str,
+    ) -> tuple[list[int], list[int]]:
+        items = convert.sequence_or_none(getattr(data, propname, None))
+        if items is None:
+            return ([], [])
+
+        flt_flags: list[int] = [self.bitflag_filter_item] * len(items)
+        flt_neworder: list[int] = []
+
+        filter_name: str = self.filter_name.casefold()
+        if not filter_name:
+            return (flt_flags, flt_neworder)
+
+        for index, item in enumerate(items):
+            if (
+                isinstance(item, VrmErrorDialogMessageLine)
+                and filter_name in item.line.casefold()
+            ):
+                continue
+            flt_flags[index] = 0
+
+        return (flt_flags, flt_neworder)
+
+    def draw_item(
+        self,
+        _context: Context,
+        layout: UILayout,
+        _data: object,
+        line: object,
+        _icon: int,
+        _active_data: object,
+        _active_prop_name: str,
+        _index: int,
+        _flt_flag: int,
+    ) -> None:
+        if not isinstance(line, VrmErrorDialogMessageLine):
+            return
+
+        column = layout.column(align=True)
+        column.label(text=line.line, translate=False)
+
+
+class VRM_OT_save_error_dialog_message(Operator, ExportHelper):
+    bl_idname = "vrm.save_error_dialog_message"
+    bl_label = "Save Error Message"
+    bl_description = "Save Error Message"
+    bl_options: ClassVar = {"REGISTER"}
+
+    filename_ext = ".txt"
+    filter_glob: StringProperty(  # type: ignore[valid-type]
+        default="*.txt",
+        options={"HIDDEN"},
+    )
+
+    title: StringProperty(options={"HIDDEN"})  # type: ignore[valid-type]
+    lines: CollectionProperty(  # type: ignore[valid-type]
+        type=VrmErrorDialogMessageLine, options={"HIDDEN"}
+    )
+
+    def _restore_error_dialog(self) -> set[str]:
+        if bpy.app.version >= (4, 1):
+            return {"FINISHED"}
+
+        return show_error_dialog(
+            self.title,
+            [output.line for output in self.lines],
+            append_environment=False,
+        )
+
+    def cancel(self, _context: Context) -> None:
+        self._restore_error_dialog()
+
+    def execute(self, _context: Context) -> set[str]:
+        message = "\n".join(output.line for output in self.lines)
+        Path(self.filepath).write_bytes(message.encode())
+        return self._restore_error_dialog()
+
+    def invoke(self, context: Context, event: Event) -> set[str]:
+        if not self.filepath:
+            local_now = dt.datetime.now(tz=None)  # Get local time # noqa: DTZ005
+            formatted_time = local_now.strftime("%Y%m%d_%H%M%S")
+            self.filepath = f"vrm_error_message_{formatted_time}.txt"
+        return ExportHelper.invoke(self, context, event)
+
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        filter_glob: str  # type: ignore[no-redef]
+        title: str  # type: ignore[no-redef]
+        lines: CollectionPropertyProtocol[  # type: ignore[no-redef]
+            VrmErrorDialogMessageLine
+        ]
+
+
+class WM_OT_vrm_error_dialog(Operator):
+    bl_label = "Error"
+    bl_idname = "wm.vrm_error_dialog"
+    bl_options: ClassVar = {"REGISTER"}
+
+    title: StringProperty(options={"HIDDEN"})  # type: ignore[valid-type]
+    lines: CollectionProperty(  # type: ignore[valid-type]
+        type=VrmErrorDialogMessageLine, options={"HIDDEN"}
+    )
+    active_line_index: IntProperty(options={"HIDDEN"})  # type: ignore[valid-type]
+
+    def execute(self, _context: Context) -> set[str]:
+        return {"FINISHED"}
+
+    def invoke(self, context: Context, _event: Event) -> set[str]:
+        self.active_line_index = len(self.lines) - 1
+        return context.window_manager.invoke_props_dialog(self, width=700)
+
+    def draw(self, _context: Context) -> None:
+        layout = self.layout.column()
+        layout.emboss = "NONE"
+        box = layout.box()
+        box.emboss = "NORMAL"
+        row = box.split(factor=0.5, align=True)
+        row.label(text=self.title, icon="ERROR")
+        save_op = layout_operator(row, VRM_OT_save_error_dialog_message, icon="FILE")
+        save_op.title = self.title
+        for process_output_line in self.lines:
+            output = save_op.lines.add()
+            output.line = process_output_line.line
+        open_url_op = layout_operator(
+            row, VRM_OT_open_url_in_web_browser, icon="URL", text="Open Support Site"
+        )
+        open_url_op.url = "https://github.com/saturday06/VRM-Addon-for-Blender/issues"
+        box.template_list(
+            VRM_UL_vrm_error_dialog_message.bl_idname,
+            "",
+            self,
+            "lines",
+            self,
+            "active_line_index",
+            rows=20,
+            sort_lock=True,
+        )
+
+    if TYPE_CHECKING:
+        # This code is auto generated.
+        # To regenerate, run the `uv run tools/property_typing.py` command.
+        title: str  # type: ignore[no-redef]
+        lines: CollectionPropertyProtocol[  # type: ignore[no-redef]
+            VrmErrorDialogMessageLine
+        ]
+        active_line_index: int  # type: ignore[no-redef]

package/browser/addons/vrm/common/fs.py

@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+from pathlib import Path
+from typing import Optional
+
+
+def create_unique_indexed_directory_path(path: Path) -> Path:
+    name = path.name
+    max_retry_count = 100_000
+    for count in range(max_retry_count):
+        count_str = f".{count}" if count else ""
+        path = path.with_name(name + count_str)
+        try:
+            path.mkdir(parents=True)
+        except FileExistsError:
+            continue
+        except OSError as exception:
+            message = f"Failed to create unique directory path: {path}"
+            raise RuntimeError(message) from exception
+        return path
+    message = (
+        "Failed to create unique directory path "
+        + f"(max retries: {max_retry_count} exceeded): {path}"
+    )
+    raise RuntimeError(message)
+
+
+def create_unique_indexed_file_path(path: Path, binary: Optional[bytes] = None) -> Path:
+    suffix = path.suffix
+    stem = path.stem
+    max_retry_count = 100_000
+
+    folder_path = path.parent
+    try:
+        folder_path.mkdir(parents=True, exist_ok=True)
+    except OSError as exception:
+        message = f"Failed to create parent directory for unique file path: {path}"
+        raise RuntimeError(message) from exception
+
+    for count in range(max_retry_count):
+        count_str = f".{count}" if count else ""
+        path = path.with_name(stem + count_str + suffix)
+
+        if binary is None:
+            try:
+                if not path.exists():
+                    return path
+            except OSError as exception:
+                message = f"Failed to create unique file path: {path}"
+                raise RuntimeError(message) from exception
+            continue
+
+        try:
+            path.touch(exist_ok=False)
+        except FileExistsError:
+            continue
+        except OSError as exception:
+            message = f"Failed to create unique file path: {path}"
+            raise RuntimeError(message) from exception
+
+        try:
+            path.write_bytes(binary)
+        except OSError as exception:
+            message = f"Failed to write data to unique file path: {path}"
+            raise RuntimeError(message) from exception
+        return path
+
+    message = (
+        "Failed to create unique file path "
+        + f"(max retries: {max_retry_count} exceeded): {path}"
+    )
+    raise RuntimeError(message)

package/browser/addons/vrm/common/gl.py

@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: MIT OR GPL-3.0-or-later
+from typing import Final
+
+GL_TRIANGLES: Final = 0x0004
+GL_BYTE: Final = 0x1400
+GL_UNSIGNED_BYTE: Final = 0x1401
+GL_SHORT: Final = 0x1402
+GL_UNSIGNED_SHORT: Final = 0x1403
+GL_INT: Final = 0x1404
+GL_UNSIGNED_INT: Final = 0x1405
+GL_FLOAT: Final = 0x1406
+GL_NEAREST: Final = 0x2600
+GL_LINEAR: Final = 0x2601
+GL_REPEAT: Final = 0x2901
+GL_CLAMP_TO_EDGE: Final = 0x812F
+GL_MIRRORED_REPEAT: Final = 0x8370
+GL_NEAREST_MIPMAP_NEAREST: Final = 0x2700
+GL_LINEAR_MIPMAP_NEAREST: Final = 0x2701
+GL_NEAREST_MIPMAP_LINEAR: Final = 0x2702
+GL_LINEAR_MIPMAP_LINEAR: Final = 0x2703