unitytk 0.0.9__tar.gz → 0.0.10__tar.gz

{unitytk-0.0.9/unitytk.egg-info → unitytk-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitytk
-Version: 0.0.9
+Version: 0.0.10
 Summary: A modular Python toolkit for Unity interaction.
 Author-email: Ryan Simpson <m3trik@outlook.com>
 License: MIT

{unitytk-0.0.9 → unitytk-0.0.10}/test/test_bool_to_fade_curve.py

@@ -1,7 +1,7 @@
 # !/usr/bin/python
 # coding=utf-8
 """Algorithm-level unit tests for the C# ``BoolToFadeCurve`` reconstruction
-logic in ``RenderOpacityController.cs``.
+logic in ``RenderEffectsController.cs``.
 
 This module ports the C# algorithm to Python and exercises it against the
 edge cases the Unity importer must handle correctly.  Catching algorithm
@@ -11,13 +11,14 @@ needs no Unity license.
 If the C# implementation drifts from this port, update both — the C# is
 the production source of truth, this is the executable spec.
 """
+
 import unittest
 from typing import List, Tuple
 
 
 # ---------------------------------------------------------------------------
 # Python port of the C# algorithm — keep behaviourally identical to
-# RenderOpacityImporter.BoolToFadeCurve in RenderOpacityController.cs.
+# RenderEffectsImporter.BoolToFadeCurve in RenderEffectsController.cs.
 # ---------------------------------------------------------------------------
 
 EPS = 0.001
@@ -143,12 +144,8 @@ class TestBoolToFadeCurve(unittest.TestCase):
     def test_fade_in_hold_fade_out(self):
         """The standard show-then-hide pattern: 0@1, 1@30, 1@100, 0@130.
         Output must be a clean 4-key curve preserving each segment."""
-        result = bool_to_fade_curve(
-            [(1, 0), (30, 1), (100, 1), (130, 0)]
-        )
-        self.assertEqual(
-            result, [(1, 0.0), (30, 1.0), (100, 1.0), (130, 0.0)]
-        )
+        result = bool_to_fade_curve([(1, 0), (30, 1), (100, 1), (130, 0)])
+        self.assertEqual(result, [(1, 0.0), (30, 1.0), (100, 1.0), (130, 0.0)])
 
     def test_complex_multi_segment(self):
         """fade-in → hold → fade-out → hold → fade-in"""
@@ -194,9 +191,7 @@ class TestBoolToFadeCurve(unittest.TestCase):
     def test_multiple_holds_track_latest_anchor(self):
         """When several same-value keys precede a transition, the ramp
         starts at the most-recent anchor (not the first)."""
-        result = bool_to_fade_curve(
-            [(0, 1), (10, 1), (20, 1), (50, 1), (60, 0)]
-        )
+        result = bool_to_fade_curve([(0, 1), (10, 1), (20, 1), (50, 1), (60, 0)])
         # prev_same_value_time advances to 50; ramp 50→60
         self.assertEqual(result, [(0, 1.0), (50, 1.0), (60, 0.0)])
 
@@ -204,9 +199,7 @@ class TestBoolToFadeCurve(unittest.TestCase):
         """When two transitions are very close, the second ramp must not
         produce a key that collides with the previous transition's end."""
         # Tight pattern: transition at t=10, immediately back at t=10.001
-        result = bool_to_fade_curve(
-            [(0, 0), (10, 1), (10.0008, 0)]
-        )
+        result = bool_to_fade_curve([(0, 0), (10, 1), (10.0008, 0)])
         # All result times must be strictly increasing
         times = [k[0] for k in result]
         for a, b in zip(times, times[1:]):
@@ -214,9 +207,7 @@ class TestBoolToFadeCurve(unittest.TestCase):
 
     def test_strictly_monotonic_output(self):
         """All emitted keys must be in strictly increasing time order."""
-        result = bool_to_fade_curve(
-            [(0, 0), (5, 1), (5, 1), (10, 0), (20, 1)]
-        )
+        result = bool_to_fade_curve([(0, 0), (5, 1), (5, 1), (10, 0), (20, 1)])
         times = [k[0] for k in result]
         for a, b in zip(times, times[1:]):
             self.assertLess(a, b)
@@ -267,8 +258,14 @@ class TestBoolToFadeCurve(unittest.TestCase):
         Reconstruction must yield 4 keys representing fade-in (0→10),
         hold (10→90), fade-out (90→150)."""
         # Times in seconds at 24fps would be 0, 0.4167, 0.4167, 3.75, 6.25, 6.25
-        raw = [(0.0, 0.0), (0.4167, 0.0), (0.4167, 1.0),
-               (3.75, 1.0), (6.25, 1.0), (6.25, 0.0)]
+        raw = [
+            (0.0, 0.0),
+            (0.4167, 0.0),
+            (0.4167, 1.0),
+            (3.75, 1.0),
+            (6.25, 1.0),
+            (6.25, 0.0),
+        ]
         result = bool_to_fade_curve(raw)
         self.assertEqual(
             result,

{unitytk-0.0.9 → unitytk-0.0.10}/test/test_controller_runtime_integration.py

@@ -9,7 +9,7 @@ Maya-free batch Unity run:
 
     1. Create a Unity project and deploy the real template package.
     2. In an Editor script, build a cube with a Standard material, drive
-       ``RenderOpacityController`` / ``EmissiveGroupController`` directly, and
+       ``RenderEffectsController`` / ``EmissiveGroupController`` directly, and
        read the resulting MaterialPropertyBlock back.
 
 Covers three behaviours that inspection alone can't settle:
@@ -34,8 +34,8 @@ Covers three behaviours that inspection alone can't settle:
 Requires:
     - Unity Hub with at least one editor installed (skips on license wall)
 """
+
 import os
-import sys
 import json
 import unittest
 import subprocess
@@ -92,7 +92,7 @@ public class ControllerRuntimeVerifier
             + (mat.HasProperty("_Color") ? "true," : "false,"));
 
         // ---- (a) Partial fade must reach the property block --------------
-        var opa = go.AddComponent<RenderOpacityController>();
+        var opa = go.AddComponent<RenderEffectsController>();
         // AddComponent in the editor DOES run Reset(), which auto-detects the
         // property — recorded here, but it is not something the import path can
         // rely on (it only helps when a material is already assigned at that
@@ -192,7 +192,8 @@ class TestControllerRuntimeIntegration(unittest.TestCase):
         os.makedirs(editor_path, exist_ok=True)
         results_path = os.path.join(self.temp_dir, "unity_results.json")
         with open(
-            os.path.join(editor_path, "ControllerRuntimeVerifier.cs"), "w",
+            os.path.join(editor_path, "ControllerRuntimeVerifier.cs"),
+            "w",
             encoding="utf-8",
         ) as f:
             f.write(UNITY_VERIFIER_CS.replace("__RESULTS_PATH__", results_path))
@@ -222,7 +223,8 @@ class TestControllerRuntimeIntegration(unittest.TestCase):
             if UnityLauncher.is_license_failure(returncode, log_text):
                 logger.info(
                     "Unity batch license failure (rc=%s) — see %s",
-                    returncode, log_path,
+                    returncode,
+                    log_path,
                 )
                 self.skipTest(UnityEnv.license_reason())
             self.fail(
@@ -243,18 +245,23 @@ class TestControllerRuntimeIntegration(unittest.TestCase):
             self.skipTest("Unity results not available — test_01 must run first")
 
         # Premise: a fresh batch project is Built-in RP.
-        self.assertTrue(unity.get("mat_has_color"),
-                        "Standard material should expose _Color")
-        self.assertFalse(unity.get("mat_has_base_color"),
-                         "premise broken: this project is no longer Built-in RP")
+        self.assertTrue(
+            unity.get("mat_has_color"), "Standard material should expose _Color"
+        )
+        self.assertFalse(
+            unity.get("mat_has_base_color"),
+            "premise broken: this project is no longer Built-in RP",
+        )
 
         # The regression: colorProperty is "_BaseColor" (the URP default the
         # component serializes) and the material has no such property, so
         # without runtime resolution the alpha never reaches it and this is 0.0.
         self.assertAlmostEqual(
-            unity.get("alpha_applied", 0.0), 0.5, places=3,
+            unity.get("alpha_applied", 0.0),
+            0.5,
+            places=3,
             msg="opacity never reached the material — colorProperty did not "
-                "resolve to the Built-in _Color",
+            "resolve to the Built-in _Color",
         )
 
     @EnvSkip.unless(_unity_available(), "no Unity editor found")
@@ -264,10 +271,13 @@ class TestControllerRuntimeIntegration(unittest.TestCase):
         if not unity:
             self.skipTest("Unity results not available — test_01 must run first")
 
-        self.assertTrue(unity.get("hidden_at_zero"),
-                        "Renderer should be disabled at zero opacity")
-        self.assertTrue(unity.get("restored_above_zero"),
-                        "Renderer should be re-enabled above zero opacity")
+        self.assertTrue(
+            unity.get("hidden_at_zero"), "Renderer should be disabled at zero opacity"
+        )
+        self.assertTrue(
+            unity.get("restored_above_zero"),
+            "Renderer should be re-enabled above zero opacity",
+        )
 
     @EnvSkip.unless(_unity_available(), "no Unity editor found")
     def test_04_property_block_coexistence(self):
@@ -278,19 +288,25 @@ class TestControllerRuntimeIntegration(unittest.TestCase):
 
         # Emissive writing _GroupWeights must not drop the opacity alpha...
         self.assertAlmostEqual(
-            unity.get("alpha_after_emissive", 0.0), 0.5, places=3,
-            msg="EmissiveGroupController wiped RenderOpacityController's alpha",
+            unity.get("alpha_after_emissive", 0.0),
+            0.5,
+            places=3,
+            msg="EmissiveGroupController wiped RenderEffectsController's alpha",
         )
         # ...and vice versa.
         self.assertAlmostEqual(
-            unity.get("weight_after_emissive", 0.0), 0.25, places=3,
+            unity.get("weight_after_emissive", 0.0),
+            0.25,
+            places=3,
             msg="_GroupWeights did not reach the property block",
         )
 
         # Destroying the controller must leave the weights intact either way.
         self.assertAlmostEqual(
-            unity.get("weight_after_destroy", 0.0), 0.25, places=3,
-            msg="destroying RenderOpacityController wiped the emissive weights",
+            unity.get("weight_after_destroy", 0.0),
+            0.25,
+            places=3,
+            msg="destroying RenderEffectsController wiped the emissive weights",
         )
 
         # KNOWN COVERAGE GAP, asserted rather than assumed: Unity does not call
@@ -305,9 +321,11 @@ class TestControllerRuntimeIntegration(unittest.TestCase):
         # future Unity DOES start firing OnDisable in edit mode, this test
         # fails loudly and the assertion above becomes real coverage.
         self.assertAlmostEqual(
-            unity.get("alpha_after_destroy", -1.0), 0.5, places=3,
+            unity.get("alpha_after_destroy", -1.0),
+            0.5,
+            places=3,
             msg="OnDisable now fires in edit mode — retarget this test at the "
-                "teardown path, which is finally reachable",
+            "teardown path, which is finally reachable",
         )
 
 

{unitytk-0.0.9 → unitytk-0.0.10}/test/test_deploy_templates.py

@@ -10,6 +10,7 @@ the Python side — the only side that can be tested without a licensed Unity
 install — including the per-component selection the DCC panels' script
 checklist drives.
 """
+
 import json
 import os
 import shutil
@@ -19,6 +20,7 @@ from unittest import mock
 
 import unitytk
 from unitytk import TemplateDeployer
+from unitytk import template_deployer
 from unitytk.template_deployer import UPM_PACKAGE_NAME
 
 
@@ -54,8 +56,10 @@ class DeployTemplateTest(unittest.TestCase):
                 "LightmapMetadataController.cs",
                 "M3trik.Unitytk.asmdef",
                 "README.md",
-                "RenderOpacityController.cs",
+                "RenderEffectsController.cs",
+                "ShadowPlane.shader",
                 "ShadowPlaneController.cs",
+                "ShadowPlaneHorizon.hlsl",
                 "ShotMetadataController.cs",
                 "UnitytkSettings.cs",
                 "package.json",
@@ -116,7 +120,7 @@ class DeployTemplateTest(unittest.TestCase):
                 "audio_event",
                 "emissive_group",
                 "lightmap_metadata",
-                "render_opacity",
+                "render_effects",
                 "shadow_plane",
                 "shot_metadata",
             ],
@@ -132,15 +136,29 @@ class DeployTemplateTest(unittest.TestCase):
         """``EmissiveGroupsLit.shader`` includes the .hlsl by RELATIVE path, so
         the pair travels with the controller that needs it — never on its own,
         never left behind."""
-        emissive = {c.key: c for c in TemplateDeployer.components()}["emissive_group"]
+        comps = {c.key: c for c in TemplateDeployer.components()}
         self.assertEqual(
-            sorted(emissive.files),
+            sorted(comps["emissive_group"].files),
             [
                 "EmissiveGroupController.cs",
                 "EmissiveGroups.hlsl",
                 "EmissiveGroupsLit.shader",
             ],
         )
+        # The shadow importer rewires planes to ``m3trik/ShadowPlane`` by
+        # Shader.Find, so the shader rides its controller the same way -- and
+        # so does the ``.hlsl`` the shader includes, which is what keeps the
+        # generated horizon body out of the mandatory ``core`` component (a
+        # name that did not start with the ``ShadowPlane`` stem would land
+        # there and deploy into every project).
+        self.assertEqual(
+            sorted(comps["shadow_plane"].files),
+            [
+                "ShadowPlane.shader",
+                "ShadowPlaneController.cs",
+                "ShadowPlaneHorizon.hlsl",
+            ],
+        )
 
     def test_satellite_goes_to_the_longest_matching_controller(self):
         """Ownership is longest-stem-wins, so adding an `EmissiveController.cs`
@@ -154,7 +172,9 @@ class DeployTemplateTest(unittest.TestCase):
             "EmissiveGroupsLit.shader",
             "UnitytkSettings.cs",
         ]
-        with mock.patch.object(TemplateDeployer, "_bundle_names", staticmethod(lambda: bundle)):
+        with mock.patch.object(
+            TemplateDeployer, "_bundle_names", staticmethod(lambda: bundle)
+        ):
             comps = {c.key: c for c in TemplateDeployer.components()}
         self.assertEqual(comps["emissive"].files, ("EmissiveController.cs",))
         self.assertEqual(
@@ -168,12 +188,71 @@ class DeployTemplateTest(unittest.TestCase):
         owned = [n for c in comps.values() for n in c.files]
         self.assertEqual(len(owned), len(set(owned)), "a file has two owners")
 
+    def test_component_graph_is_derived_once_per_bundle(self):
+        """The bundle is fixed at install time, so the graph is derived ONCE
+        and the templates dir is scanned once -- not per call.
+
+        Every entry point re-enters :meth:`components`: ``resolve_components``
+        -> ``resolve_files`` -> ``deploy_package``/``status``, and the panels
+        rebuild their checklist from it on every UI refresh. Measured before
+        this was cached, one ``uninstall_package`` re-derived the graph 3x and
+        re-scanned the bundle dir 3x (``run_action('uninstall')``: 4x).
+        """
+        counts = {"iterdir": 0}
+        real_resources = template_deployer.resources
+
+        class _Traversable:
+            def __init__(self, wrapped):
+                self._wrapped = wrapped
+
+            def iterdir(self):
+                counts["iterdir"] += 1
+                return self._wrapped.iterdir()
+
+            def __getattr__(self, name):
+                return getattr(self._wrapped, name)
+
+        class _Resources:
+            def files(self, package):
+                return _Traversable(real_resources.files(package))
+
+            def __getattr__(self, name):
+                return getattr(real_resources, name)
+
+        TemplateDeployer.deploy_package(self.project)
+        with mock.patch.object(template_deployer, "resources", _Resources()):
+            TemplateDeployer.components()  # warm, whatever the process order
+            before = counts["iterdir"]
+            graph = TemplateDeployer.components()
+            self.assertIs(graph, TemplateDeployer.components(), "graph rebuilt")
+            TemplateDeployer.resolve_files(["audio_event"])
+            TemplateDeployer.status(self.project)
+            TemplateDeployer.uninstall_package(self.project, ["audio_event"])
+            self.assertEqual(
+                counts["iterdir"] - before, 0, "the bundle dir was re-scanned"
+            )
+
+    def test_component_graph_tracks_the_bundle_it_was_derived_from(self):
+        """The memo is keyed on the bundle names, so a different bundle yields
+        a different graph -- the cache can never serve a stale set."""
+        real = TemplateDeployer.components()
+        bundle = ["FooController.cs", "UnitytkSettings.cs"]
+        with mock.patch.object(
+            TemplateDeployer, "_bundle_names", staticmethod(lambda: bundle)
+        ):
+            self.assertEqual(
+                sorted(c.key for c in TemplateDeployer.components()), ["core", "foo"]
+            )
+        self.assertIs(TemplateDeployer.components(), real)
+
     def test_keys_and_labels_survive_an_acronym(self):
         """Names are split on real word boundaries, so a `UVLayoutController`
         reads as 'UV Layout' / `uv_layout` rather than 'U V Layout'."""
         self.assertEqual(TemplateDeployer._component_key("UVLayout"), "uv_layout")
         self.assertEqual(TemplateDeployer._component_label("UVLayout"), "UV Layout")
-        self.assertEqual(TemplateDeployer._component_key("ShotMetadata"), "shot_metadata")
+        self.assertEqual(
+            TemplateDeployer._component_key("ShotMetadata"), "shot_metadata"
+        )
 
     def test_selected_deploy_carries_core_and_nothing_else(self):
         """A checked subset deploys those components + the core they compile
@@ -233,7 +312,9 @@ class DeployTemplateTest(unittest.TestCase):
         TemplateDeployer.deploy_package(self.project)
         with self.assertRaises(ValueError):
             TemplateDeployer.uninstall_package(self.project, ["core"])
-        self.assertTrue(os.path.isfile(os.path.join(self.package, "UnitytkSettings.cs")))
+        self.assertTrue(
+            os.path.isfile(os.path.join(self.package, "UnitytkSettings.cs"))
+        )
 
     def test_status_reports_not_installed_then_up_to_date(self):
         """The panels' Status action: absent → installed=False with the full
@@ -297,9 +378,7 @@ class DeployTemplateTest(unittest.TestCase):
         self.assertIn("[ ] Shot Metadata", text)
 
     def test_run_action_install_and_uninstall_the_checked_set(self):
-        install = TemplateDeployer.run_action(
-            self.project, "install", ["audio_event"]
-        )
+        install = TemplateDeployer.run_action(self.project, "install", ["audio_event"])
         self.assertEqual([lvl for lvl, _ in install], ["info"])
         self.assertIn("Audio Event", install[0][1])
         self.assertTrue(
@@ -365,7 +444,7 @@ class DeployTemplateTest(unittest.TestCase):
         "AudioEventController.cs",
         "EmissiveGroupController.cs",
         "LightmapMetadataController.cs",
-        "RenderOpacityController.cs",
+        "RenderEffectsController.cs",
         "ShadowPlaneController.cs",
         "ShotMetadataController.cs",
     }
@@ -374,7 +453,8 @@ class DeployTemplateTest(unittest.TestCase):
         """Deploy the set; return ``(definers, referencers)`` of *shared_class*
         across the C# templates only."""
         written = [
-            p for p in TemplateDeployer.deploy_package(self.project)
+            p
+            for p in TemplateDeployer.deploy_package(self.project)
             if p.endswith(".cs")
         ]
         definers, referencers = set(), set()

{unitytk-0.0.9 → unitytk-0.0.10}/test/test_fade_window_preservation.py

@@ -15,8 +15,8 @@ Pipeline:
        expected mid-points, assert ramp lengths roughly match the Maya
        authoring (within tolerance for FBX time conversion).
 """
+
 import os
-import sys
 import json
 import shutil
 import unittest
@@ -49,7 +49,7 @@ def _unity_available() -> bool:
 # fade-out 91→151 (60f / 2.5s).  Hold from 11 to 91.
 # ---------------------------------------------------------------------------
 
-MAYA_EXPORT_SCRIPT = r'''
+MAYA_EXPORT_SCRIPT = r"""
 import sys, os, json
 # mayatk/pythontk repo roots arrive via PYTHONPATH set by the parent test.
 
@@ -91,7 +91,7 @@ with open(os.path.join(output_dir, "maya_results.json"), "w") as f:
     json.dump({"fbx_path": fbx_path, "fbx_exists": os.path.exists(fbx_path)}, f)
 print(f"MAYA EXPORT COMPLETE: {fbx_path}")
 maya.standalone.uninitialize()
-'''
+"""
 
 
 # ---------------------------------------------------------------------------
@@ -142,7 +142,7 @@ public class FadeWindowVerifier
             foreach (var b in AnimationUtility.GetCurveBindings(clip))
             {
                 if (b.propertyName != "opacity") continue;
-                if (b.type != typeof(RenderOpacityController)) continue;
+                if (b.type != typeof(RenderEffectsController)) continue;
                 found = true;
 
                 var curve = AnimationUtility.GetEditorCurve(clip, b);
@@ -224,7 +224,10 @@ class TestFadeWindowPreservation(unittest.TestCase):
         env["PYTHONIOENCODING"] = "utf-8"
         proc = subprocess.run(
             [MAYAPY, script, self.temp_dir],
-            capture_output=True, text=True, env=env, timeout=180,
+            capture_output=True,
+            text=True,
+            env=env,
+            timeout=180,
         )
         if proc.returncode != 0:
             self.fail(f"mayapy failed:\n{proc.stderr[-2000:]}")
@@ -243,16 +246,19 @@ class TestFadeWindowPreservation(unittest.TestCase):
 
         assets = os.path.join(project_path, "Assets")
         unitytk.TemplateDeployer.deploy_package(project_path)
-        shutil.copy2(self.__class__.fbx_path,
-                     os.path.join(assets, "fade_window.fbx"))
+        shutil.copy2(self.__class__.fbx_path, os.path.join(assets, "fade_window.fbx"))
 
         editor = os.path.join(assets, "Editor")
         os.makedirs(editor, exist_ok=True)
         results = os.path.join(self.temp_dir, "verify.json")
-        with open(os.path.join(editor, "FadeWindowVerifier.cs"),
-                  "w", encoding="utf-8") as f:
-            f.write(UNITY_VERIFIER_CS.replace(
-                "__RESULTS_PATH__", results.replace("\\", "/")))
+        with open(
+            os.path.join(editor, "FadeWindowVerifier.cs"), "w", encoding="utf-8"
+        ) as f:
+            f.write(
+                UNITY_VERIFIER_CS.replace(
+                    "__RESULTS_PATH__", results.replace("\\", "/")
+                )
+            )
 
         launcher.project_path = project_path
         proc = launcher.launch_editor(
@@ -268,8 +274,9 @@ class TestFadeWindowPreservation(unittest.TestCase):
         with open(results) as f:
             r = json.load(f)
 
-        self.assertTrue(r["opacity_curve_found"],
-                        f"No opacity curve. Samples: {r.get('samples')}")
+        self.assertTrue(
+            r["opacity_curve_found"], f"No opacity curve. Samples: {r.get('samples')}"
+        )
 
         # Maya-authored: fade-in 10 frames, fade-out 60 frames.  At 24 fps
         # that's 0.417s and 2.5s respectively.  FBX/Unity may massage
@@ -280,22 +287,27 @@ class TestFadeWindowPreservation(unittest.TestCase):
         logger.info(f"fade_in={fade_in:.4f}s  fade_out={fade_out:.4f}s")
 
         self.assertAlmostEqual(
-            fade_in, 10.0 / 24.0, delta=0.05,
+            fade_in,
+            10.0 / 24.0,
+            delta=0.05,
             msg=f"Short fade-in collapsed: expected ~0.417s, got {fade_in}s. "
-                f"Samples: {r.get('samples')}",
+            f"Samples: {r.get('samples')}",
         )
         self.assertAlmostEqual(
-            fade_out, 60.0 / 24.0, delta=0.05,
+            fade_out,
+            60.0 / 24.0,
+            delta=0.05,
             msg=f"Long fade-out collapsed: expected ~2.5s, got {fade_out}s. "
-                f"This is the original BoolToFadeCurve bug — every fade "
-                f"became 0.5s regardless of artist intent. "
-                f"Samples: {r.get('samples')}",
+            f"This is the original BoolToFadeCurve bug — every fade "
+            f"became 0.5s regardless of artist intent. "
+            f"Samples: {r.get('samples')}",
         )
 
         # Sanity: the two fades must differ — if BoolToFadeCurve still
         # used a hardcoded constant, both would be 0.5s.
         self.assertGreater(
-            fade_out, fade_in * 2,
+            fade_out,
+            fade_in * 2,
             f"Fades collapsed to the same length (in={fade_in}, out={fade_out}) "
             f"— BoolToFadeCurve is not using authored key spacing.",
         )

{unitytk-0.0.9 → unitytk-0.0.10}/test/test_keyed_visibility.py

@@ -17,8 +17,8 @@ visibility-related properties (m_IsActive, m_Enabled, Visibility) and
 reports which object paths have them, how many keys, and what values
 the visibility has at specific sample frames.
 """
+
 import os
-import sys
 import json
 import shutil
 import unittest
@@ -45,7 +45,7 @@ FBX_PATH = asset_path("fixture_keyed_visibility.fbx")
 #: fixture names resolving for one release).
 FBX_ASSET_NAME = "fixture_keyed_visibility.fbx"
 
-# Template CS files — need RenderOpacityController for the importer
+# Template CS files — need RenderEffectsController for the importer
 TEMPLATE_DIR = os.path.join(
     os.path.dirname(__file__), os.pardir, "unitytk", "templates"
 )
@@ -393,9 +393,10 @@ def _sources_available() -> bool:
     return os.path.isfile(FBX_PATH)
 
 
-@EnvSkip.unless(_sources_available(),
-                "keyed-visibility fixture FBX not accessible "
-                "(set UNITYTK_TEST_ASSETS)")
+@EnvSkip.unless(
+    _sources_available(),
+    "keyed-visibility fixture FBX not accessible (set UNITYTK_TEST_ASSETS)",
+)
 @EnvSkip.unless(_find_unity_exe(), "no Unity editor found")
 class TestKeyedVisibility(unittest.TestCase):
     """Verify all keyed visibility from the fixture FBX imports correctly
@@ -431,7 +432,7 @@ class TestKeyedVisibility(unittest.TestCase):
 
         # === Step 1: Create fresh Unity project ===
         logger.info(f"Creating Unity project: {self.project_path}")
-        proc = subprocess.run(
+        subprocess.run(
             [
                 unity_exe,
                 "-createProject",
@@ -455,7 +456,7 @@ class TestKeyedVisibility(unittest.TestCase):
         os.makedirs(scripts_dir, exist_ok=True)
         for cs_name in [
             "UnitytkSettings.cs",
-            "RenderOpacityController.cs",
+            "RenderEffectsController.cs",
             "AudioEventController.cs",
         ]:
             src = os.path.join(TEMPLATE_DIR, cs_name)
@@ -496,7 +497,7 @@ class TestKeyedVisibility(unittest.TestCase):
         logger.info(
             "Launching Unity batch-mode verification (this may take a few minutes)..."
         )
-        proc = subprocess.run(
+        subprocess.run(
             [
                 unity_exe,
                 "-projectPath",