unitytk 0.0.4__tar.gz → 0.0.6__tar.gz

{unitytk-0.0.4/unitytk.egg-info → unitytk-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitytk
-Version: 0.0.4
+Version: 0.0.6
 Summary: A modular Python toolkit for Unity interaction.
 Author-email: Ryan Simpson <m3trik@outlook.com>
 License: MIT
@@ -15,7 +15,7 @@ License-File: LICENSE
 Requires-Dist: pythontk>=0.7.71
 Dynamic: license-file
 
-[![Tests](https://img.shields.io/badge/Tests-116%20passed-brightgreen.svg)](../test/)
+[![Tests](https://img.shields.io/badge/Tests-124%20passed-brightgreen.svg)](../test/)
 
 # unitytk
 

{unitytk-0.0.4 → unitytk-0.0.6}/docs/README.md

@@ -1,4 +1,4 @@
-[![Tests](https://img.shields.io/badge/Tests-116%20passed-brightgreen.svg)](../test/)
+[![Tests](https://img.shields.io/badge/Tests-124%20passed-brightgreen.svg)](../test/)
 
 # unitytk
 

{unitytk-0.0.4 → unitytk-0.0.6}/test/test_audio_events_integration.py

@@ -461,7 +461,11 @@ class TestAudioEventsIntegration(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.temp_dir = tempfile.mkdtemp(prefix="audio_events_integ_")
+        # In-repo scratch (see CLAUDE.md), not the system temp dir —
+        # these preserve a full Unity project on purpose.
+        _temp_base = os.path.join(os.path.dirname(__file__), "temp_tests")
+        os.makedirs(_temp_base, exist_ok=True)
+        cls.temp_dir = tempfile.mkdtemp(prefix="audio_events_integ_", dir=_temp_base)
         cls.fbx_path = None
         cls.maya_results = None
         cls.unity_results = None

{unitytk-0.0.4 → unitytk-0.0.6}/test/test_clip_name_contract_integration.py

@@ -198,7 +198,11 @@ class TestClipNameContract(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.temp_dir = tempfile.mkdtemp(prefix="clip_name_contract_")
+        # In-repo scratch (see CLAUDE.md), not the system temp dir —
+        # these preserve a full Unity project on purpose.
+        _temp_base = os.path.join(os.path.dirname(__file__), "temp_tests")
+        os.makedirs(_temp_base, exist_ok=True)
+        cls.temp_dir = tempfile.mkdtemp(prefix="clip_name_contract_", dir=_temp_base)
         cls.fbx_path = None
         cls.maya_results = None
         cls.unity_results = None

unitytk-0.0.6/test/test_controller_runtime_integration.py

@@ -0,0 +1,323 @@
+# !/usr/bin/python
+# coding=utf-8
+"""Integration test: unitytk runtime controller behaviour inside a real Unity.
+
+The import-side templates are well covered by the per-channel integration
+tests, but the *runtime* half (what the MonoBehaviours actually do to a
+Renderer) had no live coverage at all. This test closes that gap with a
+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
+       read the resulting MaterialPropertyBlock back.
+
+Covers three behaviours that inspection alone can't settle:
+
+    a. **Built-in RP color-property resolution.** A fresh Unity project is
+       Built-in RP, whose materials expose ``_Color`` — not the ``_BaseColor``
+       the component serializes by default. When the two disagree the apply
+       returns early and the object hard-pops at zero instead of fading.
+       ``Reset()`` auto-detects on the normal import path (measured in
+       ``test_render_opacity_controller``), but it cannot help when the
+       material arrives after the component, when a prefab authored under one
+       pipeline is opened under another, or in a player build where ``Reset``
+       does not exist at all — so the runtime resolution is what actually
+       guarantees it. This test forces the serialized ``_BaseColor`` back after
+       ``AddComponent`` to measure that path specifically.
+    b. **Auto-hide at zero**, and restoring visibility above zero.
+    c. **Property-block co-existence.** Both controllers write to the same
+       Renderer's MaterialPropertyBlock. Each must read-modify-write it; a
+       blanket ``MaterialPropertyBlock.Clear()`` on teardown would wipe the
+       other's data.
+
+Requires:
+    - Unity Hub with at least one editor installed (skips on license wall)
+"""
+import os
+import sys
+import json
+import tempfile
+import unittest
+import subprocess
+import logging
+
+logger = logging.getLogger(__name__)
+
+scripts_dir = r"O:\Cloud\Code\_scripts"
+if scripts_dir not in sys.path:
+    sys.path.insert(0, scripts_dir)
+
+from unitytk import UnityLauncher, UnityFinder, TemplateDeployer
+
+
+def _unity_available() -> bool:
+    return bool(UnityFinder.find_editors())
+
+
+# ======================================================================
+# Unity-side verifier
+# ======================================================================
+
+UNITY_VERIFIER_CS = r"""
+using UnityEngine;
+using UnityEditor;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+public class ControllerRuntimeVerifier
+{
+    /// <summary>Invariant-culture float, so a European locale can't emit
+    /// "0,5" and hand the Python side unparseable JSON.</summary>
+    static string F(float v) => v.ToString("R", CultureInfo.InvariantCulture);
+
+    // Called via -executeMethod ControllerRuntimeVerifier.Verify
+    public static void Verify()
+    {
+        string resultsFile = @"__RESULTS_PATH__";
+        var sb = new StringBuilder();
+        sb.AppendLine("{");
+
+        // ---- Setup: cube + Built-in RP Standard material ----------------
+        var go = GameObject.CreatePrimitive(PrimitiveType.Cube);
+        var rend = go.GetComponent<Renderer>();
+        var mat = new Material(Shader.Find("Standard"));
+        mat.name = "OpacityRuntimeTestMat";
+        rend.sharedMaterial = mat;
+
+        // Documents the premise: a fresh project really is Built-in RP, so
+        // the serialized "_BaseColor" default names a property that is absent.
+        sb.AppendLine("  \"mat_has_base_color\": "
+            + (mat.HasProperty("_BaseColor") ? "true," : "false,"));
+        sb.AppendLine("  \"mat_has_color\": "
+            + (mat.HasProperty("_Color") ? "true," : "false,"));
+
+        // ---- (a) Partial fade must reach the property block --------------
+        var opa = go.AddComponent<RenderOpacityController>();
+        // 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
+        // moment). Force the serialized URP default back so what follows
+        // measures the RUNTIME resolution, which always applies.
+        sb.AppendLine("  \"reset_autodetected\": "
+            + (opa.colorProperty == "_Color" ? "true," : "false,"));
+        opa.colorProperty = "_BaseColor";
+
+        opa.opacity = 0.5f;
+        opa.ApplyNow();
+
+        var mpb = new MaterialPropertyBlock();
+        rend.GetPropertyBlock(mpb);
+        sb.AppendLine("  \"alpha_applied\": " + F(mpb.GetColor("_Color").a) + ",");
+
+        // ---- (b) Auto-hide at zero, restore above zero -------------------
+        opa.opacity = 0f;
+        opa.ApplyNow();
+        sb.AppendLine("  \"hidden_at_zero\": " + (!rend.enabled ? "true," : "false,"));
+
+        opa.opacity = 1f;
+        opa.ApplyNow();
+        sb.AppendLine("  \"restored_above_zero\": " + (rend.enabled ? "true," : "false,"));
+
+        // Back to a partial fade for the co-existence check.
+        opa.opacity = 0.5f;
+        opa.ApplyNow();
+
+        // ---- (c) Second controller on the same Renderer ------------------
+        var emi = go.AddComponent<EmissiveGroupController>();
+        emi.groups.Add(new EmissiveGroup {
+            name = "headlights", slot = 0, weight = 0.25f });
+        emi.Rebuild();
+        emi.ApplyNow();
+
+        rend.GetPropertyBlock(mpb);
+        sb.AppendLine("  \"alpha_after_emissive\": "
+            + F(mpb.GetColor("_Color").a) + ",");
+        sb.AppendLine("  \"weight_after_emissive\": "
+            + F(mpb.GetVector("_GroupWeights").x) + ",");
+
+        // Tearing the opacity controller down must leave the emissive weights
+        // alone. Measured: Unity does NOT call OnDisable for a plain
+        // (non-[ExecuteAlways]) MonoBehaviour in edit mode, so this does not
+        // reach ClearOverrides — the alpha readback below is what proves that,
+        // and the Python side asserts it so the day it changes we find out.
+        Object.DestroyImmediate(opa);
+        rend.GetPropertyBlock(mpb);
+        sb.AppendLine("  \"alpha_after_destroy\": "
+            + F(mpb.GetColor("_Color").a) + ",");
+        sb.AppendLine("  \"weight_after_destroy\": "
+            + F(mpb.GetVector("_GroupWeights").x));
+
+        Object.DestroyImmediate(go);
+
+        sb.AppendLine("}");
+        File.WriteAllText(resultsFile, sb.ToString());
+        Debug.Log("CONTROLLER RUNTIME TEST COMPLETE. Results at: " + resultsFile);
+        EditorApplication.Exit(0);
+    }
+}
+"""
+
+
+# ======================================================================
+# Test class
+# ======================================================================
+
+
+class TestControllerRuntimeIntegration(unittest.TestCase):
+    """unitytk MonoBehaviour runtime behaviour, read back from a live Unity."""
+
+    @classmethod
+    def setUpClass(cls):
+        # In-repo scratch (see CLAUDE.md), not the system temp dir.
+        _temp_base = os.path.join(os.path.dirname(__file__), "temp_tests")
+        os.makedirs(_temp_base, exist_ok=True)
+        cls.temp_dir = tempfile.mkdtemp(prefix="ctrl_runtime_integ_", dir=_temp_base)
+        cls.unity_results = None
+        logger.info(f"Temp dir: {cls.temp_dir}")
+
+    @classmethod
+    def tearDownClass(cls):
+        logger.info(f"Results preserved in: {cls.temp_dir}")
+
+    @unittest.skipUnless(_unity_available(), "No Unity editor found")
+    def test_01_unity_runtime(self):
+        """Drive both controllers in a real Unity; capture the readback."""
+        editor = os.environ.get("UNITYTK_TEST_EDITOR")
+        launcher = UnityLauncher(editor) if editor else UnityLauncher()
+        project_path = os.path.join(self.temp_dir, "UnityProject")
+        if not launcher.create_project(project_path, batch_mode=True):
+            self.skipTest(
+                "Unity batch project creation failed — typically no batch-mode "
+                "license on this machine."
+            )
+
+        # Deploy the real templates -- the full embedded UPM package.
+        TemplateDeployer.deploy_package(project_path)
+
+        editor_path = os.path.join(project_path, "Assets", "Editor")
+        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",
+            encoding="utf-8",
+        ) as f:
+            f.write(UNITY_VERIFIER_CS.replace("__RESULTS_PATH__", results_path))
+
+        log_path = os.path.join(self.temp_dir, "unity_log.txt")
+        launcher.project_path = project_path
+        proc = launcher.launch_editor(
+            batch_mode=True,
+            execute_method="ControllerRuntimeVerifier.Verify",
+            log_file=log_path,
+            extra_args=["-quit"],
+            detached=False,
+        )
+        returncode = None
+        if proc:
+            try:
+                returncode = proc.wait(timeout=300)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                raise TimeoutError("Unity timed out")
+
+        if not os.path.exists(results_path):
+            log_text = ""
+            if os.path.exists(log_path):
+                with open(log_path, encoding="utf-8", errors="ignore") as fh:
+                    log_text = fh.read()
+            if UnityLauncher.is_license_failure(returncode, log_text):
+                self.skipTest(
+                    "Unity exited without a valid batch license "
+                    f"(rc={returncode}) — see {log_path}"
+                )
+            self.fail(
+                f"unity_results.json not created (Unity rc={returncode}) — "
+                f"check {log_path}"
+            )
+        with open(results_path) as f:
+            self.__class__.unity_results = json.load(f)
+        logger.info(
+            f"Unity results:\n{json.dumps(self.__class__.unity_results, indent=2)}"
+        )
+
+    @unittest.skipUnless(_unity_available(), "No Unity editor found")
+    def test_02_color_property_resolves_on_builtin(self):
+        """The fade reaches the material even though the default names _BaseColor."""
+        unity = self.__class__.unity_results
+        if not unity:
+            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")
+
+        # 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,
+            msg="opacity never reached the material — colorProperty did not "
+                "resolve to the Built-in _Color",
+        )
+
+    @unittest.skipUnless(_unity_available(), "No Unity editor found")
+    def test_03_auto_hide_at_zero(self):
+        """Zero opacity disables the Renderer; raising it restores visibility."""
+        unity = self.__class__.unity_results
+        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")
+
+    @unittest.skipUnless(_unity_available(), "No Unity editor found")
+    def test_04_property_block_coexistence(self):
+        """Two controllers share one Renderer's block without clobbering."""
+        unity = self.__class__.unity_results
+        if not unity:
+            self.skipTest("Unity results not available — test_01 must run first")
+
+        # 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",
+        )
+        # ...and vice versa.
+        self.assertAlmostEqual(
+            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",
+        )
+
+        # KNOWN COVERAGE GAP, asserted rather than assumed: Unity does not call
+        # OnDisable for a plain (non-[ExecuteAlways]) MonoBehaviour in edit
+        # mode, so DestroyImmediate above does NOT reach ClearOverrides — the
+        # alpha stays at the value we last applied instead of reverting to the
+        # material's own. That makes the weight assertion above necessary but
+        # not sufficient: the teardown path itself (read-modify-write of the
+        # property block, rather than a blanket Clear() that would wipe the
+        # emissive weights) is only exercised in play mode, which batch
+        # -executeMethod cannot enter synchronously. Pinned here so that if a
+        # 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,
+            msg="OnDisable now fires in edit mode — retarget this test at the "
+                "teardown path, which is finally reachable",
+        )
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+    unittest.main(verbosity=2)