unitytk 0.0.11__tar.gz → 0.0.13__tar.gz

{unitytk-0.0.11/unitytk.egg-info → unitytk-0.0.13}/PKG-INFO

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

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_asset_delivery.py

@@ -10,7 +10,6 @@ from pythontk.core_utils.app_handoff import HandoffRequest, Payload
 from unitytk.asset_delivery import (
     CopyToAssetsDeliverer,
     FileToUnityBridge,
-    CopyToAssetsDeliverer,
 )
 
 

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_audio_events_integration.py

@@ -25,7 +25,6 @@ Requires:
     - Unity Hub with at least one editor installed
 """
 import os
-import sys
 import json
 import shutil
 import unittest

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_clip_name_contract_integration.py

@@ -2,19 +2,21 @@
 # coding=utf-8
 """Integration test: the Maya→Unity clip-name JOIN contract under stress.
 
-The whole shots→Unity scheme hinges on one identity: the FBX take name == the
-imported ``AnimationClip.name`` == the ``shot_metadata`` ``clip`` join key.  Maya
-guarantees the first equality (single resolution) and sanitizes to strictly
-``[A-Za-z0-9_]``; this test proves the *second* — that Unity preserves such names
-verbatim on FBX import — for the cases most likely to diverge: a space, embedded
-punctuation, a leading digit, and an exact collision (de-duped with a suffix).
+The whole shots→Unity scheme hinges on one identity: the shot name == the FBX
+take name == the imported ``AnimationClip.name`` == the ``shot_metadata`` ``clip``
+join key.  The store refuses any name outside ``ShotStore.NAME_PATTERN``
+(``[A-Za-z0-9_]``, unique ignoring case) instead of respelling it on export, so
+what the user typed is what ships.  This test proves both halves end to end:
+Maya refuses the names the carrier would respell, and every name it accepts
+arrives in Unity VERBATIM -- including the forms the pre-2026-09-18 respelling
+collapsed or stripped (a doubled ``_``, a trailing ``_``), a leading digit and
+a leading ``_``.
 
 If Unity ever re-sanitized clip names (e.g. stripped a leading digit), the join
 would silently break and ``ShotMetadataController.GetShot`` would return null; this
 test is the guard against that.
 """
 import os
-import sys
 import json
 import shutil
 import unittest
@@ -36,14 +38,16 @@ from unitytk import UnityLauncher, UnityFinder, TemplateDeployer
 #: any other machine while the run still reported green.
 MAYAPY = MayaEnv.mayapy()
 
-# Authored shot name -> expected sanitized clip key (Maya side, verified by the
-# mayatk pure tests).  Unity must reproduce these exactly as clip names.
-EXPECTED = {
-    "01 Start": "01_Start",      # leading digit + space
-    "Fade-In!": "Fade_In",       # punctuation
-    "Wipe Out": "Wipe_Out",      # space
-    "Wipe Out!": "Wipe_Out_1",   # collides with "Wipe Out" -> suffixed
-}
+# Names the store accepts; each must be the clip key AND the Unity clip name,
+# character for character.
+NAMES = [
+    "01_Start",  # leading digit
+    "Fade__In",  # doubled underscore (the legacy respelling collapsed it)
+    "Wipe_Out_",  # trailing underscore (the legacy respelling stripped it)
+    "_Lead",  # leading underscore
+]
+# Names the store refuses rather than let the export respell them.
+REFUSED = ["01 Start", "Fade-In!", "fade__in"]  # space, punctuation, case twin
 
 
 def _unity_available() -> bool:
@@ -60,8 +64,10 @@ maya.standalone.initialize(name="python")
 import maya.cmds as cmds
 import maya.mel as mel
 
+import pythontk as ptk
 from mayatk.anim_utils.shots._shots import ShotStore
 from mayatk.env_utils.fbx_utils import FbxUtils
+from mayatk.node_utils.data_nodes import DataNodes
 
 output_dir = sys.argv[1]
 fbx_path = os.path.join(output_dir, "clip_name_contract.fbx").replace(os.sep, "/")
@@ -77,16 +83,24 @@ for t, v in ((1, 0.0), (5, 1.0), (10, 2.0), (15, 3.0), (20, 4.0),
 
 store = ShotStore()
 ShotStore.set_active(store)
-# Order is significant: "Wipe Out" before "Wipe Out!" so the collision suffixes
-# the second one (matches the deterministic resolve over sorted order).
-store.define_shot("01 Start", 1, 10)
-store.define_shot("Fade-In!", 11, 20)
-store.define_shot("Wipe Out", 21, 30)
-store.define_shot("Wipe Out!", 31, 40)
+names = json.loads(sys.argv[2])
+for i, name in enumerate(names):
+    store.define_shot(name, 1 + 10 * i, 10 + 10 * i)
+refused = []
+for name in json.loads(sys.argv[3]):
+    try:
+        store.define_shot(name, 41, 45)
+    except ValueError:
+        refused.append(name)
 
 view = store.to_export_view()
 store.publish_export_view()
 n_takes = FbxUtils.apply_takes_from_node()
+# The take list the split realizes, read back off the carrier through the ONE
+# reader of it (each shot_metadata clip's own range).
+takes = ptk.SceneRecords.declared_takes(
+    lambda key: ptk.SceneRecords.resolve(key).load(DataNodes)
+)
 
 if not cmds.pluginInfo("fbxmaya", query=True, loaded=True):
     cmds.loadPlugin("fbxmaya")
@@ -98,7 +112,9 @@ results = {
     "fbx_path": fbx_path,
     "fbx_exists": os.path.exists(fbx_path),
     "n_takes": n_takes,
-    "clip_keys": [t["name"] for t in view["fbx_takes"]],
+    "clip_keys": [t["name"] for t in takes],
+    "meta_keys": [s["clip"] for s in view["shot_metadata"]["shots"]],
+    "refused": refused,
 }
 with open(os.path.join(output_dir, "maya_results.json"), "w") as f:
     json.dump(results, f, indent=2)
@@ -214,7 +230,7 @@ class TestClipNameContract(unittest.TestCase):
         )
         env["PYTHONIOENCODING"] = "utf-8"
         proc = subprocess.run(
-            [MAYAPY, script_path, self.temp_dir],
+            [MAYAPY, script_path, self.temp_dir, json.dumps(NAMES), json.dumps(REFUSED)],
             capture_output=True, text=True, timeout=180, env=env,
         )
         if proc.stderr:
@@ -226,9 +242,12 @@ class TestClipNameContract(unittest.TestCase):
         r = self.__class__.maya_results
         self.__class__.fbx_path = r["fbx_path"]
         self.assertTrue(r["fbx_exists"])
-        self.assertEqual(r["n_takes"], 4)
-        # Maya half already produced the expected sanitized keys.
-        self.assertEqual(set(r["clip_keys"]), set(EXPECTED.values()))
+        self.assertEqual(r["n_takes"], len(NAMES))
+        # The Maya half: every refused name was refused, every accepted name
+        # is its own take and join key, unchanged and in order.
+        self.assertEqual(r["refused"], REFUSED)
+        self.assertEqual(r["clip_keys"], NAMES)
+        self.assertEqual(r["meta_keys"], NAMES)
 
     @MayaEnv.skip_unless_available()
     @EnvSkip.unless(_unity_available(), "no Unity editor found")
@@ -304,18 +323,17 @@ class TestClipNameContract(unittest.TestCase):
         clip_names = set(unity.get("clip_names", []))
         clip_keys = set(unity.get("clip_keys", []))
 
-        # Every expected sanitized name imported as a clip with that exact name —
-        # space→_, punctuation→_, leading digit, and collision suffix all survive
-        # Unity's FBX import verbatim.  (Unity also imports a default "Take 001"
-        # clip for the full baked timeline; it carries no shot record and is
-        # ignored by the join — so this is a superset check, not equality.)
-        for sanitized in EXPECTED.values():
+        # Every authored name imported as a clip with that exact name.  (Unity
+        # also imports a default "Take 001" clip for the full baked timeline; it
+        # carries no shot record and is ignored by the join — so this is a
+        # superset check, not equality.)
+        for name in NAMES:
             self.assertIn(
-                sanitized, clip_names,
-                f"Unity altered/dropped clip {sanitized!r}; imported: {sorted(clip_names)}",
+                name, clip_names,
+                f"Unity altered/dropped clip {name!r}; imported: {sorted(clip_names)}",
             )
-        # Metadata keys are exactly the four shots, and each joins to a clip.
-        self.assertEqual(clip_keys, set(EXPECTED.values()))
+        # Metadata keys are exactly the authored shots, and each joins to a clip.
+        self.assertEqual(clip_keys, set(NAMES))
         for key in clip_keys:
             self.assertIn(key, clip_names, f"Join broken: key {key!r} has no clip.")
 

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_emissive_groups_integration.py

@@ -7,9 +7,9 @@ transports, curve rebinding, proxy-node deletion) and was the only one with no
 batch-Unity coverage at all. This closes the import-side half:
 
     1. Maya (mayapy): cube → two real ``EmissiveGroups.add_group`` calls with
-       distinct default weights → ``FbxUtils.run_export_preparers()`` (the
-       registered known-producer refresh the Scene Exporter calls, validating
-       the ``_KNOWN_PRODUCERS`` wiring) → export mesh + ``data_export`` carrier.
+       distinct default weights → ``FbxUtils.publish()`` (the one publish of
+       every producer the Scene Exporter makes, validating the
+       ``FbxUtils.PRODUCERS`` wiring) → export mesh + ``data_export`` carrier.
        Then clear the groups and export a SECOND FBX with no channel.
     2. Unity (batchmode): import the first FBX with the real templates
        deployed and verify the populated ``EmissiveGroupController`` on the
@@ -30,7 +30,6 @@ Requires:
     - Unity Hub with at least one editor installed (skips on license wall)
 """
 import os
-import sys
 import json
 import shutil
 import unittest
@@ -70,6 +69,7 @@ import maya.standalone
 maya.standalone.initialize(name="python")
 import maya.cmds as cmds
 
+import pythontk as ptk
 from mayatk.mat_utils.emissive_groups import EmissiveGroups
 from mayatk.env_utils.fbx_utils import FbxUtils
 from mayatk.node_utils.data_nodes import DataNodes
@@ -86,10 +86,10 @@ EmissiveGroups.add_group("taillights", faces=[cube + ".f[2:3]"], default=0.25)
 
 warnings = EmissiveGroups.validate()
 
-# The registered known-producer refresh — exactly what the Scene Exporter
-# calls before an export (validates the _KNOWN_PRODUCERS wiring).
-FbxUtils.run_export_preparers()
-manifest = DataNodes.get_export_string(EmissiveGroups.DATA_CHANNEL)
+# The one publish of every producer -- exactly what the Scene Exporter makes
+# before an export (validates the FbxUtils.PRODUCERS wiring).
+FbxUtils.publish()
+manifest = DataNodes.read(ptk.Scope.DELIVERABLE, EmissiveGroups.DATA_CHANNEL)
 
 if not cmds.pluginInfo("fbxmaya", query=True, loaded=True):
     cmds.loadPlugin("fbxmaya")
@@ -109,8 +109,8 @@ _export(with_path)
 # Second export with the channel gone — drives the stale-removal path.
 for name in list(EmissiveGroups.list_groups()):
     EmissiveGroups.remove_group(name)
-FbxUtils.run_export_preparers()
-cleared = DataNodes.get_export_string(EmissiveGroups.DATA_CHANNEL)
+FbxUtils.publish()
+cleared = DataNodes.read(ptk.Scope.DELIVERABLE, EmissiveGroups.DATA_CHANNEL)
 
 without_path = os.path.join(output_dir, "Lamp_emissive_cleared.fbx")
 _export(without_path)
@@ -233,7 +233,7 @@ class TestEmissiveGroupsIntegration(unittest.TestCase):
 
     @MayaEnv.skip_unless_available()
     def test_01_maya_export(self):
-        """cube → two add_group calls → run_export_preparers → FBX with carrier."""
+        """cube → two add_group calls → FbxUtils.publish → FBX with carrier."""
         script_path = os.path.join(self.temp_dir, "maya_export.py")
         with open(script_path, "w", encoding="utf-8") as f:
             f.write(MAYA_EXPORT_SCRIPT)

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_fade_window_preservation.py

@@ -57,7 +57,7 @@ import maya.standalone
 maya.standalone.initialize(name="python")
 import maya.cmds as cmds
 import maya.mel as mel
-from mayatk import RenderOpacity
+from mayatk import RenderEffects
 
 output_dir = sys.argv[1]
 fbx_path = os.path.join(output_dir, "fade_window.fbx")
@@ -68,12 +68,12 @@ cmds.currentUnit(time="film")
 cmds.playbackOptions(min=1, max=160)
 
 cube = cmds.polyCube(name="WindowCube")[0]
-RenderOpacity.create(objects=[cube], mode="attribute")
+RenderEffects.create(objects=[cube], mode="attribute")
 
 # Short fade-in: frame 1 → 11 (10 frames, 0.417s @ 24fps)
-RenderOpacity.key_fade(objects=[cube], start=1, end=11, direction="in")
+RenderEffects.key_fade(objects=[cube], start=1, end=11, direction="in")
 # Long fade-out: frame 91 → 151 (60 frames, 2.5s @ 24fps)
-RenderOpacity.key_fade(objects=[cube], start=91, end=151, direction="out")
+RenderEffects.key_fade(objects=[cube], start=91, end=151, direction="out")
 
 # Add a translate carrier so the FBX has a clip spanning the timeline
 cmds.setKeyframe(cube, attribute="translateY", time=1, value=0)

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_keyed_visibility.py

@@ -523,7 +523,7 @@ class TestKeyedVisibility(unittest.TestCase):
                 logger.error(f"Unity log tail:\n{tail}")
                 # Check for compilation errors
                 if "error CS" in log_content:
-                    errors = [l for l in log_content.split("\n") if "error CS" in l]
+                    errors = [ln for ln in log_content.split("\n") if "error CS" in ln]
                     for e in errors[:10]:
                         logger.error(f"  {e.strip()}")
 
@@ -545,7 +545,7 @@ class TestKeyedVisibility(unittest.TestCase):
         self.assertTrue(r.get("import_visibility"), "importVisibility was not enabled")
         self.assertTrue(r.get("import_animation"), "importAnimation was not enabled")
         self.assertFalse(r.get("resample_curves"), "resampleCurves should be OFF")
-        print(f"  Import Settings: visibility=ON, animation=ON, resample=OFF")
+        print("  Import Settings: visibility=ON, animation=ON, resample=OFF")
 
         # Prefab
         self.assertTrue(r.get("prefab_loaded"), "FBX prefab failed to load")
@@ -626,7 +626,7 @@ class TestKeyedVisibility(unittest.TestCase):
         print(f"  Found with curves:          {len(found)}")
         print(f"  MISSING curves:             {len(missing)}")
         if missing:
-            print(f"\n  *** MISSING VISIBILITY CURVES ***")
+            print("\n  *** MISSING VISIBILITY CURVES ***")
             for m in missing:
                 in_hierarchy = any(m in obj for obj in loc_objects)
                 status = "IN HIERARCHY" if in_hierarchy else "NOT IN FBX"
@@ -638,7 +638,7 @@ class TestKeyedVisibility(unittest.TestCase):
         if sample_error:
             print(f"\n  Sampling Error: {sample_error}")
         elif sample_results:
-            print(f"\n  AnimationMode Sampling:")
+            print("\n  AnimationMode Sampling:")
             for sr in sample_results:
                 print(f"    {sr}")
 
@@ -657,8 +657,8 @@ class TestKeyedVisibility(unittest.TestCase):
             print(
                 f"\n  WARNING: {len(missing)} expected objects missing visibility curves"
             )
-            print(f"  These objects may need .visibility keyed directly in Maya")
-            print(f"  (display layer visibility does NOT export to FBX)")
+            print("  These objects may need .visibility keyed directly in Maya")
+            print("  (display layer visibility does NOT export to FBX)")
 
         print("\n  VERDICT: See results above for visibility import status.")
         print("=" * 70 + "\n")

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_launcher.py

@@ -1,7 +1,7 @@
 import unittest
 import os
 import sys
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch
 
 # Ensure unitytk and module imports work whether run directly or via runner
 try:

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_lightmap_metadata_integration.py

@@ -27,7 +27,6 @@ Requires:
     - Unity Hub with at least one editor installed
 """
 import os
-import sys
 import json
 import shutil
 import unittest
@@ -68,6 +67,7 @@ maya.standalone.initialize(name="python")
 import maya.cmds as cmds
 import maya.mel as mel
 
+import pythontk as ptk
 from mayatk.light_utils.lightmap_baker.lightmap_baker import LightmapBaker
 from mayatk.uv_utils._uv_utils import UvUtils
 from mayatk.node_utils.data_nodes import DataNodes
@@ -104,7 +104,7 @@ except Exception:
 
 long = cmds.ls(cube, long=True)[0]
 baker = LightmapBaker(resolution=64)
-baker.commit_lightmap({long: tex_path}, intensity=1.0)
+baker.commit_lightmap({long: tex_path})
 
 # Material must be untouched (the whole point of lighting-only mode).
 sgs_after = cmds.listConnections(shape, type="shadingEngine") or []
@@ -124,7 +124,9 @@ results = {
     "fbx_exists": os.path.exists(fbx_path),
     "material_kept": material_kept,
     "real_exr": real_exr,
-    "metadata": json.loads(DataNodes.get_export_string(LightmapBaker.LIGHTMAP_METADATA)),
+    "metadata": json.loads(
+        DataNodes.read(ptk.Scope.DELIVERABLE, LightmapBaker.LIGHTMAP_METADATA)
+    ),
 }
 with open(os.path.join(output_dir, "maya_results.json"), "w") as f:
     json.dump(results, f, indent=2)
@@ -284,7 +286,76 @@ public class LightmapMetaTestVerifier
             + (nonDirectional ? "true," : "false,"));
         sb.AppendLine("  \"tex_type_lightmap\": " + (texLightmap ? "true," : "false,"));
         sb.AppendLine("  \"tex_srgb_off\": " + (texSrgbOff ? "true," : "false,"));
-        sb.AppendLine("  \"tex_mips_on\": " + (texMips ? "true" : "false"));
+        sb.AppendLine("  \"tex_mips_on\": " + (texMips ? "true," : "false,"));
+
+        // Same-named objects bind by hierarchy, as ONE assignment (the rule
+        // pythontk's GLB applier follows): FBX carries leaf names only, so a
+        // production room's two machine bodies are both BODY, and the
+        // manifest is the whole SCENE's, so a partial export carries records
+        // whose objects are not here.  Built in memory; the REAL (private)
+        // ResolveRenderers settles each case.
+        string byHierarchy = "not run";
+        try
+        {
+            Func<string, Transform, bool, Transform> node = (nodeName, under, withRenderer) =>
+            {
+                var go = new GameObject(nodeName);
+                go.transform.SetParent(under, false);
+                if (withRenderer) go.AddComponent<MeshRenderer>();
+                return go.transform;
+            };
+            var resolve = typeof(LightmapMetadataApplier).GetMethod("ResolveRenderers",
+                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
+            // -> (bound, ambiguous) for these records under that root.
+            Func<Transform, LightmapRecord[], Tuple<Dictionary<LightmapRecord, Renderer>, HashSet<LightmapRecord>>> call =
+                (under, recs) =>
+                {
+                    var args = new object[] { under, new List<LightmapRecord>(recs), null };
+                    var map = (Dictionary<LightmapRecord, Renderer>)resolve.Invoke(null, args);
+                    return Tuple.Create(map, (HashSet<LightmapRecord>)args[2]);
+                };
+            var root = new GameObject("fr_root").transform;
+            var lxLeaf = node("BODY", node("BODY", node("MACHINE_B", root, false), false), true)
+                .GetComponent<Renderer>();
+            var alLeaf = node("BODY", node("MACHINE_A", root, false), true)
+                .GetComponent<Renderer>();
+            var lx = new LightmapRecord { name = "BODY", hierarchy = new[] { "room", "MACHINE_B", "BODY", "BODY" } };
+            var al = new LightmapRecord { name = "BODY", hierarchy = new[] { "room", "MACHINE_A", "BODY" } };
+            var vend = new LightmapRecord { name = "BODY", hierarchy = new[] { "room", "VENDING", "BODY" } };
+
+            // Both bodies bind their own; a third BODY whose object is not
+            // here binds nothing and is not called ambiguous either.
+            var full = call(root, new[] { lx, al, vend });
+            bool own = full.Item1.TryGetValue(lx, out var r1) && r1 == lxLeaf
+                && full.Item1.TryGetValue(al, out var r2) && r2 == alLeaf;
+            bool absent = !full.Item1.ContainsKey(vend) && !full.Item2.Contains(vend);
+
+            // A partial export: only the MACHINE_A is here. The MACHINE_B's
+            // record found only that BODY and took it, overwriting its map.
+            var solo = new GameObject("fr_solo").transform;
+            var soloLeaf = node("BODY", node("MACHINE_A", solo, false), true)
+                .GetComponent<Renderer>();
+            var part = call(solo, new[] { lx, al });
+            bool partial = part.Item1.Count == 1
+                && part.Item1.TryGetValue(al, out var r3) && r3 == soloLeaf;
+
+            // Same-named records with no hierarchy are never guessed.
+            var bare = call(root, new[] {
+                new LightmapRecord { name = "BODY" }, new LightmapRecord { name = "BODY" } });
+            bool unguessed = bare.Item1.Count == 0 && bare.Item2.Count == 2;
+
+            byHierarchy = (own ? "ok" : "bodies missed") + "|"
+                + (absent ? "ok" : "an absent record bound") + "|"
+                + (partial ? "ok" : "partial export mis-bound") + "|"
+                + (unguessed ? "ok" : "no-hierarchy duplicates guessed");
+            UnityEngine.Object.DestroyImmediate(root.gameObject);
+            UnityEngine.Object.DestroyImmediate(solo.gameObject);
+        }
+        catch (Exception e)
+        {
+            byHierarchy = "raised: " + e.GetType().Name + " " + e.Message;
+        }
+        sb.AppendLine("  \"find_by_hierarchy\": \"" + Escape(byHierarchy) + "\"");
 
         sb.AppendLine("}");
 
@@ -366,6 +437,11 @@ class TestLightmapMetadataIntegration(unittest.TestCase):
         self.assertIn("Crate", objs)
         self.assertEqual(objs["Crate"]["map"], "Crate_Lightmap.exr")
         self.assertEqual(objs["Crate"]["uvIndex"], 1)
+        # The map is a join token by FILE NAME: the manifest carries no
+        # authoring folder (the absolute ``dir`` / ``dirs`` it once published
+        # resolved nowhere but the baking machine).
+        self.assertNotIn("dir", r["metadata"])
+        self.assertNotIn("dirs", r["metadata"])
 
     # ---- Step 2: Unity import ----------------------------------------
 
@@ -499,6 +575,13 @@ class TestLightmapMetadataIntegration(unittest.TestCase):
         self.assertTrue(unity.get("tex_srgb_off"), "sRGB not pinned off")
         self.assertTrue(unity.get("tex_mips_on"), "mipmaps not pinned on")
 
+        # (e) same-named objects bind by hierarchy, not first match (the
+        # production room: MACHINE_B|BODY|BODY beside MACHINE_A|BODY); a record
+        # without a hierarchy, as older manifests carry, still takes the first.
+        self.assertEqual(
+            unity.get("find_by_hierarchy"), "ok|ok|ok|ok", unity.get("find_by_hierarchy")
+        )
+
 
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_multi_section_audio_integration.py

@@ -903,7 +903,7 @@ class TestMultiSectionAudioIntegration(unittest.TestCase):
                         audio_stems,
                         f"{obj_name}: clip '{name}' not in source audio dir",
                     )
-            print(f"    Clip names verified against source audio directory")
+            print("    Clip names verified against source audio directory")
 
         # ================================================================
         # 3. RenderEffectsController — components + Renderer gating
@@ -917,7 +917,7 @@ class TestMultiSectionAudioIntegration(unittest.TestCase):
         print(f"    With Renderer:          {oc_with_rend}")
         print(f"    Without Renderer:       {oc_without_rend}")
         if oc_details:
-            print(f"    Details (first 5):")
+            print("    Details (first 5):")
             for d in oc_details[:5]:
                 print(f"      {d}")
             if len(oc_details) > 5:
@@ -960,7 +960,7 @@ class TestMultiSectionAudioIntegration(unittest.TestCase):
         # ================================================================
         binding_freq = r.get("curve_binding_freq", [])
         if binding_freq:
-            print(f"\n  Curve binding frequency (top 20):")
+            print("\n  Curve binding frequency (top 20):")
             for entry in binding_freq[:20]:
                 print(f"    {entry}")
             if len(binding_freq) > 20:
@@ -1023,7 +1023,7 @@ class TestMultiSectionAudioIntegration(unittest.TestCase):
         # Find keys like "opacity_curve_samples_Take 001"
         sample_keys = [k for k in r if k.startswith("opacity_curve_samples_")]
         if sample_keys:
-            print(f"\n  Opacity curve samples:")
+            print("\n  Opacity curve samples:")
             for sk in sample_keys:
                 samples = r[sk]
                 print(f"    [{sk}] ({len(samples)} curves sampled)")
@@ -1082,7 +1082,7 @@ class TestMultiSectionAudioIntegration(unittest.TestCase):
         audio_stems = set(_collect_audio_files(AUDIO_DIR))
         if event_time_keys:
             all_event_names_from_clip: set[str] = set()
-            print(f"\n  Audio event times:")
+            print("\n  Audio event times:")
             for etk in event_time_keys:
                 events = r[etk]
                 print(f"    [{etk}] {len(events)} events")
@@ -1205,7 +1205,7 @@ class TestMultiSectionAudioIntegration(unittest.TestCase):
         ri_oc = r.get("reimport_opacity_controllers", -1)
         ri_ac = r.get("reimport_audio_controllers", -1)
 
-        print(f"\n  Reimport idempotency:")
+        print("\n  Reimport idempotency:")
         print(f"    Events:        {total_events} -> {ri_events}")
         print(f"    Opa curves:    {oc_curves_rebound} -> {ri_opacity}")
         print(f"    audio_trigger: {at_curves} -> {ri_at}")
@@ -1248,7 +1248,7 @@ class TestMultiSectionAudioIntegration(unittest.TestCase):
         changed_500 = r.get("anim_sample_changed_by_t500", 0)
         anim_details = r.get("anim_sample_details", [])
 
-        print(f"\n  AnimationMode runtime sampling:")
+        print("\n  AnimationMode runtime sampling:")
         print(f"    Controllers sampled: {anim_count}")
         print(f"    Changed by t=15s:    {changed_15}")
         print(f"    Changed by t=500s:   {changed_500}")
@@ -1264,8 +1264,8 @@ class TestMultiSectionAudioIntegration(unittest.TestCase):
         self.assertGreater(
             changed_15 + changed_500,
             0,
-            f"No opacity values changed between t=0 and t=15s/t=500s — "
-            f"curves may not be driving RenderEffectsController.opacity",
+            "No opacity values changed between t=0 and t=15s/t=500s — "
+            "curves may not be driving RenderEffectsController.opacity",
         )
 
         print("=" * 70)

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_render_opacity_controller.py

@@ -59,7 +59,7 @@ import maya.standalone
 maya.standalone.initialize(name="python")
 import maya.cmds as cmds
 import maya.mel as mel
-from mayatk import RenderOpacity
+from mayatk import RenderEffects
 
 output_dir = sys.argv[1]
 fbx_path = os.path.join(output_dir, "fade_test.fbx")
@@ -71,7 +71,7 @@ cmds.playbackOptions(min=1, max=140)
 cube = cmds.polyCube(name="FadeCube")[0]
 
 # Initialize attribute-mode fade
-RenderOpacity.setup(objects=[cube], mode="attribute")
+RenderEffects.create(objects=[cube], mode="attribute")
 
 # Animate opacity: Fade In -> Hold -> Fade Out
 cmds.cutKey(cube, attribute="opacity")

{unitytk-0.0.11 → unitytk-0.0.13}/test/test_render_opacity_e2e.py

@@ -11,8 +11,8 @@ curve values, reimport idempotency).
 Pipeline:
     1. Maya (mayapy): build a cube + 'opacity' attr, key opacity in a
        4-key fade-in/hold/fade-out pattern, call
-       :meth:`RenderOpacity.prepare_for_export` to dual-key visibility,
-       export FBX.
+       :meth:`RenderEffects.prepare_for_export` to stage the curve proxy
+       (nothing keys visibility), export FBX.
     2. Unity (batchmode): deploy ``UnitytkSettings.cs`` (the shared
        ImportGate/CarrierImport home), ``RenderEffectsController.cs`` and
        ``AudioEventController.cs``.  Import the FBX.  Verify:
@@ -65,7 +65,7 @@ def _unity_available() -> bool:
 # ======================================================================
 
 MAYA_EXPORT_SCRIPT = r'''
-"""Executed inside mayapy — keys opacity, dual-keys visibility, exports FBX."""
+"""Executed inside mayapy — keys opacity, stages the curve proxy, exports FBX."""
 import sys, os, json
 
 # mayatk/pythontk repo roots arrive via PYTHONPATH set by the parent test.
@@ -75,7 +75,7 @@ maya.standalone.initialize(name="python")
 import maya.cmds as cmds
 import maya.mel as mel
 
-from mayatk.mat_utils.render_opacity._render_opacity import RenderOpacity
+from mayatk.mat_utils.render_opacity.render_effects import RenderEffects
 
 output_dir = sys.argv[1]
 fbx_path = os.path.join(output_dir, "opacity_test.fbx")
@@ -86,7 +86,7 @@ cmds.playbackOptions(min=1, max=140)
 cube = cmds.polyCube(name="fade_cube")[0]
 
 # Initialize attribute-mode opacity (creates the 'opacity' attr)
-RenderOpacity.create(objects=[cube], mode="attribute")
+RenderEffects.create(objects=[cube], mode="attribute")
 
 # Author a 4-key fade-in → hold → fade-out pattern
 cmds.cutKey(cube, attribute="opacity")
@@ -97,11 +97,12 @@ cmds.setKeyframe(cube, attribute="opacity", time=140, value=0.0)  # faded out
 
 assert cmds.attributeQuery("opacity", node=str(cube), exists=True)
 
-# Dual-key visibility from opacity — the Unity importer reconstructs the
-# fade from these step-keyed visibility transitions because Unity collapses
-# importAnimatedCustomProperties curves to the root and loses per-object
-# binding.
-synced = RenderOpacity.prepare_for_export(objects=[cube])
+# Stage the curve-proxy transport: a fade_cube__opacity child carries the
+# opacity curve on scale.x, which the importer rebinds to the controller
+# (Unity flattens animated custom properties onto the root). Nothing keys
+# visibility: presence is derived from the authored opacity downstream.
+synced = RenderEffects.prepare_for_export()
+proxies = cmds.ls("*__opacity") or []
 
 vis_keys = cmds.keyframe(cube, attribute="visibility", q=True, tc=True) or []
 opa_keys = cmds.keyframe(cube, attribute="opacity",    q=True, tc=True) or []
@@ -127,6 +128,7 @@ results = {
     "opacity_keys": opa_keys,
     "visibility_keys": vis_keys,
     "synced_objects": synced,
+    "proxies": proxies,
 }
 
 with open(os.path.join(output_dir, "maya_results.json"), "w") as f:
@@ -407,7 +409,7 @@ class TestRenderOpacityE2E(unittest.TestCase):
 
     @MayaEnv.skip_unless_available()
     def test_01_maya_export(self):
-        """Author opacity, dual-key visibility via prepare_for_export, export FBX."""
+        """Author opacity, stage the curve proxy via prepare_for_export, export FBX."""
         script_path = os.path.join(self.temp_dir, "maya_export.py")
         with open(script_path, "w", encoding="utf-8") as f:
             f.write(MAYA_EXPORT_SCRIPT)
@@ -444,12 +446,11 @@ class TestRenderOpacityE2E(unittest.TestCase):
         r = self.__class__.maya_results
         self.__class__.fbx_path = r["fbx_path"]
         self.assertTrue(r["fbx_exists"])
-        # prepare_for_export must have dual-keyed visibility
-        self.assertGreater(
-            len(r["visibility_keys"]),
-            0,
-            "prepare_for_export should have synced visibility keys",
+        # prepare_for_export stages the curve proxy and keys no visibility
+        self.assertTrue(
+            r["proxies"], "prepare_for_export should have staged the opacity proxy"
         )
+        self.assertEqual(r["visibility_keys"], [], "no visibility mirror is written")
         # The opacity keys should match what we authored
         opa_set = {int(round(t)) for t in r["opacity_keys"]}
         self.assertEqual(opa_set, {1, 20, 100, 140})