unitytk 0.2.0__tar.gz → 0.2.2__tar.gz

{unitytk-0.2.0/unitytk.egg-info → unitytk-0.2.2}/PKG-INFO

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

{unitytk-0.2.0 → unitytk-0.2.2}/test/test_asset_delivery.py

@@ -1,6 +1,7 @@
 # !/usr/bin/python
 # coding=utf-8
 """Tests for unitytk.CopyToAssetsDeliverer -- copy-to-Assets hand-off Strategy (no DCC)."""
+
 import json
 import os
 import struct
@@ -20,6 +21,7 @@ class _Logger:
         self.errors = []
         self.warnings = []
         self.infos = []
+        self.debugs = []
 
     def error(self, m, *args):
         self.errors.append(m % args if args else m)
@@ -30,6 +32,9 @@ class _Logger:
     def info(self, m, *args):
         self.infos.append(m % args if args else m)
 
+    def debug(self, m, *args):
+        self.debugs.append(m % args if args else m)
+
 
 def _carrier_fbx(path: str, channels) -> str:
     """A binary FBX (7700 layout) whose ``data_export`` carrier holds
@@ -108,7 +113,9 @@ def _payload(fbx, default_name="Export"):
 
 class SanitizeTest(unittest.TestCase):
     def test_strips_invalid_and_paths(self):
-        self.assertEqual(CopyToAssetsDeliverer.sanitize_asset_name("my/model:v2"), "my_model_v2")
+        self.assertEqual(
+            CopyToAssetsDeliverer.sanitize_asset_name("my/model:v2"), "my_model_v2"
+        )
 
     def test_collapses_and_trims(self):
         self.assertEqual(CopyToAssetsDeliverer.sanitize_asset_name("  a   b  "), "a b")
@@ -160,6 +167,31 @@ class DeliveryTest(unittest.TestCase):
         self.assertEqual(open(dest, "rb").read(), b"FBX-BYTES")
         self.assertFalse(result["launched"])
 
+    def test_a_copy_cut_short_never_replaces_the_asset_unity_reads(self):
+        """The copy lands whole or not at all (``ptk.FileUtils.atomic_write``):
+        a copy into the project cut short (a full disk, a sync client holding
+        the file) left Unity a truncated FBX under the asset's own name.
+        Added: 2026-10-13"""
+        from unittest import mock
+
+        import unitytk.asset_delivery as delivery
+
+        dest = os.path.join(self.project, "Assets", "Models", "Robot.fbx")
+        os.makedirs(os.path.dirname(dest))
+        with open(dest, "wb") as fh:
+            fh.write(b"OLD")
+
+        def cut_short(src, dst, *args, **kwargs):
+            with open(dst, "wb") as fh:
+                fh.write(b"HALF")
+            raise OSError(28, "No space left on device")
+
+        with mock.patch.object(delivery.shutil, "copy2", side_effect=cut_short):
+            self._deliver({"ASSETS_SUBDIR": "Models"}, default_name="Robot")
+        with open(dest, "rb") as fh:
+            self.assertEqual(fh.read(), b"OLD")
+        self.assertEqual(os.listdir(os.path.dirname(dest)), ["Robot.fbx"])
+
     def test_deliver_uses_default_subdir_and_asset_name(self):
         _bridge, result = self._deliver({}, default_name="Cube")
         self.assertEqual(
@@ -168,7 +200,9 @@ class DeliveryTest(unittest.TestCase):
         )
 
     def test_explicit_asset_name_overrides_and_sanitizes(self):
-        _bridge, result = self._deliver({"ASSET_NAME": "Hero/Mesh:01"}, default_name="Cube")
+        _bridge, result = self._deliver(
+            {"ASSET_NAME": "Hero/Mesh:01"}, default_name="Cube"
+        )
         self.assertEqual(os.path.basename(result["asset"]), "Hero_Mesh_01.fbx")
 
     def test_launch_mode_open_invokes_windowed_launch(self):
@@ -257,6 +291,7 @@ class DeliveryTest(unittest.TestCase):
         orig = ad.CopyToAssetsDeliverer._launch_editor
         # Patch UnityLauncher inside the real hook (deferred import target).
         import unitytk.launcher as launcher_mod
+
         real = launcher_mod.UnityLauncher
         launcher_mod.UnityLauncher = _FakeLauncher
         try:
@@ -319,15 +354,14 @@ class DeliveryTest(unittest.TestCase):
             )
             # Genuinely under Assets/ (no drive escape).
             assets = os.path.realpath(os.path.join(self.project, "Assets"))
-            self.assertTrue(
-                os.path.realpath(dest).startswith(assets), f"raw={raw!r}"
-            )
+            self.assertTrue(os.path.realpath(dest).startswith(assets), f"raw={raw!r}")
 
     def test_explicit_subdir_reducing_to_nothing_drops_into_assets_root(self):
         for raw in (".", "/", "../.."):
             _bridge, result = self._deliver({"ASSETS_SUBDIR": raw}, default_name="Cube")
             self.assertEqual(
-                result["asset"], os.path.join(self.project, "Assets", "Cube.fbx"),
+                result["asset"],
+                os.path.join(self.project, "Assets", "Cube.fbx"),
                 f"raw={raw!r}",
             )
             self.assertEqual(result["subdir"], "")
@@ -363,7 +397,11 @@ class SelfContainedDeliveryTest(unittest.TestCase):
         "lightmap_metadata": {
             "version": 1,
             "objects": [{"name": "Crate", "map": "Crate_Lightmap.exr", "uvIndex": 1}],
-            "probe": {"map": "Room_Probe.exr", "position": [0, 0, 0], "unit_scale": 0.01},
+            "probe": {
+                "map": "Room_Probe.exr",
+                "position": [0, 0, 0],
+                "unit_scale": 0.01,
+            },
         },
         "shadow_metadata": {
             "version": 2,
@@ -386,7 +424,12 @@ class SelfContainedDeliveryTest(unittest.TestCase):
         self.maps = os.path.join(self.tmp, "sourceimages")
         os.makedirs(self.maps)
         self.bytes = {}
-        for name in ("Crate_Lightmap.exr", "Room_Probe.exr", "Crate_shadow.png", "Crate_horizon.png"):
+        for name in (
+            "Crate_Lightmap.exr",
+            "Room_Probe.exr",
+            "Crate_shadow.png",
+            "Crate_horizon.png",
+        ):
             self.bytes[name] = name.encode() * 8
             with open(os.path.join(self.maps, name), "wb") as fh:
                 fh.write(self.bytes[name])

{unitytk-0.2.0 → unitytk-0.2.2}/test/test_audio_events_integration.py

@@ -24,6 +24,7 @@ Requires:
     - Maya 2025 installed (mayapy.exe)
     - Unity Hub with at least one editor installed
 """
+
 import os
 import json
 import shutil
@@ -34,7 +35,15 @@ import logging
 logger = logging.getLogger(__name__)
 
 import base_test  # noqa: F401 — sys.path bootstrap for the sibling repos
-from base_test import EnvSkip, MayaEnv, TempProjects, UnityEnv, UserPropsProbe
+from base_test import (
+    BlenderEnv,
+    CarrierFbx,
+    EnvSkip,
+    MayaEnv,
+    TempProjects,
+    UnityEnv,
+    UserPropsProbe,
+)
 
 scripts_dir = base_test.SCRIPTS_ROOT
 
@@ -471,9 +480,7 @@ class TestAudioEventsIntegration(unittest.TestCase):
             events,
             {("", 9, "footstep"), ("", 29, "jump"), ("", 44, "land")},
         )
-        self.assertEqual(
-            sorted(r["tracks"]), ["footstep", "jump", "land"]
-        )
+        self.assertEqual(sorted(r["tracks"]), ["footstep", "jump", "land"])
 
     # ------------------------------------------------------------------
     # Step 2: Unity import and readback
@@ -552,17 +559,26 @@ class TestAudioEventsIntegration(unittest.TestCase):
                 full_log = f.read()
             # Surface AudioEvent / error / warning lines for analysis
             relevant = [
-                ln for ln in full_log.splitlines()
-                if any(s in ln for s in (
-                    "AudioEvent", "ERROR", "Error", "Warning",
-                    "NullReferenceException", "Failed",
-                ))
+                ln
+                for ln in full_log.splitlines()
+                if any(
+                    s in ln
+                    for s in (
+                        "AudioEvent",
+                        "ERROR",
+                        "Error",
+                        "Warning",
+                        "NullReferenceException",
+                        "Failed",
+                    )
+                )
             ]
             self.__class__.unity_log_relevant = relevant
             if relevant:
                 logger.info(
                     "Unity log relevant lines (%d):\n  %s",
-                    len(relevant), "\n  ".join(relevant[-40:])
+                    len(relevant),
+                    "\n  ".join(relevant[-40:]),
                 )
             else:
                 logger.info("Unity log: no AudioEvent/Warning/Error lines.")
@@ -571,8 +587,7 @@ class TestAudioEventsIntegration(unittest.TestCase):
         with open(results_path) as f:
             self.__class__.unity_results = json.load(f)
 
-        postproc_path = os.path.join(
-            self.temp_dir, UserPropsProbe.RESULTS_FILENAME)
+        postproc_path = os.path.join(self.temp_dir, UserPropsProbe.RESULTS_FILENAME)
         if os.path.exists(postproc_path):
             with open(postproc_path) as f:
                 self.__class__.postproc = json.load(f)
@@ -608,7 +623,8 @@ class TestAudioEventsIntegration(unittest.TestCase):
             f"in postprocessor results: {list(postproc)}",
         )
         self.assertIn(
-            "audio_manifest", props,
+            "audio_manifest",
+            props,
             f"audio_manifest user-property missing on {name}; saw: {list(props)}",
         )
         manifest = props["audio_manifest"]
@@ -655,7 +671,8 @@ class TestAudioEventsIntegration(unittest.TestCase):
 
         # (d) AnimationEvents injected on the imported clip
         self.assertGreaterEqual(
-            unity.get("clip_count", 0), 1,
+            unity.get("clip_count", 0),
+            1,
             "Expected at least one AnimationClip in the imported FBX",
         )
         events = unity.get("animation_events", [])
@@ -676,8 +693,8 @@ class TestAudioEventsIntegration(unittest.TestCase):
         # In Unity-frame terms the events are at clip-relative frames 9,
         # 29, 44 — which is what AnimationEvent.time * frameRate yields.
         self.assertEqual(events_by_name.get("footstep"), 9)
-        self.assertEqual(events_by_name.get("jump"),    29)
-        self.assertEqual(events_by_name.get("land"),    44)
+        self.assertEqual(events_by_name.get("jump"), 29)
+        self.assertEqual(events_by_name.get("land"), 44)
 
         # (e) Reimport idempotency.  Two probes injected before the
         # reimport tell us about both correctness and Unity behavior:
@@ -721,6 +738,140 @@ class TestAudioEventsIntegration(unittest.TestCase):
             )
 
 
+# ======================================================================
+# Carrier precedence: one audio_manifest per model, the scene's own first
+# ======================================================================
+
+CARRIER_VERIFIER_CS = r"""
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+
+public class AudioCarrierVerifier
+{
+    static string Q(string s) { return "\"" + (s ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"") + "\""; }
+
+    public static void Verify()
+    {
+        var o = new List<string>();
+        try
+        {
+            // Again, now the clips are in the database: the startup import
+            // may have met the model before the audio.
+            AssetDatabase.ImportAsset("__FBX__",
+                ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
+            AssetDatabase.Refresh();
+            var prefab = AssetDatabase.LoadAssetAtPath<GameObject>("__FBX__");
+            o.Add("\"prefab\":" + (prefab != null ? "true" : "false"));
+            var nodes = prefab != null
+                ? prefab.GetComponentsInChildren<Transform>(true).Select(t => Q(t.name))
+                : Enumerable.Empty<string>();
+            o.Add("\"nodes\":[" + string.Join(",", nodes) + "]");
+            var ctrl = prefab != null ? prefab.GetComponent<AudioEventController>() : null;
+            o.Add("\"controller\":" + (ctrl != null ? "true" : "false"));
+            var clips = ctrl != null ? ctrl.clips : new List<AudioClip>();
+            o.Add("\"clips\":[" + string.Join(",", clips.Select(c => Q(c != null ? c.name : ""))) + "]");
+        }
+        catch (Exception e) { o.Add("\"error\":" + Q(e.GetType().Name + ": " + e.Message)); }
+        File.WriteAllText(@"__RESULTS__", "{" + string.Join(",\n", o) + "}");
+        EditorApplication.Exit(0);
+    }
+}
+"""
+
+
+class TestAudioCarrierPrecedence(unittest.TestCase):
+    """An FBX carrying ``audio_manifest`` on several carriers plays the
+    scene's own only.
+
+    An assembly ships a stray ``data_export1`` (and a module's
+    ``NS:data_export``) beside the scene's own, each holding the events as
+    last exported alone -- measured on an assembly, 2026-10-13. The scene's
+    own record is re-derived from the whole merged scene, so every reader
+    takes ONE carrier per channel, the scene's own first: the other
+    importers (``CarrierImport.Collect``), the GLB applier, and pythontk's
+    ``FbxMedia.audio_events``. The audio importer concatenated every
+    carrier's events instead, so the stray's stale event was bound and fired.
+
+    The fixture is a real FBX with both carriers (``base_test.CarrierFbx``,
+    written by a fresh Blender); pythontk's ``FbxMedia.audio_events`` pins the
+    same rule on the same shape (``test_fbx_media``).
+    """
+
+    FBX = "Assets/Delivered/assembly.fbx"
+
+    @classmethod
+    def setUpClass(cls):
+        cls.temp_dir = TempProjects.allocate("audio_carrier_precedence")
+
+    @BlenderEnv.skip_unless_available()
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_the_scenes_own_carrier_wins(self):
+        own = {"version": 2, "events": [{"clip": "", "frame": 0, "name": "footstep"}]}
+        stray = {"version": 2, "events": [{"clip": "", "frame": 3, "name": "door"}]}
+        fixture = CarrierFbx.build(
+            os.path.join(self.temp_dir, "assembly.fbx"),
+            {
+                "data_export": {"audio_manifest": own},
+                "data_export1": {"audio_manifest": stray},
+            },
+        )
+
+        launcher = UnityLauncher()
+        project = os.path.join(self.temp_dir, "UnityProject")
+        if not launcher.create_project(project, batch_mode=True):
+            self.skipTest(UnityEnv.project_creation_reason())
+        delivered = os.path.join(project, "Assets", "Delivered")
+        os.makedirs(delivered, exist_ok=True)
+        shutil.copy2(fixture, os.path.join(delivered, "assembly.fbx"))
+        # Both tracks resolve, so only the carrier rule decides what binds.
+        for name in ("footstep", "door"):
+            CarrierFbx.wav(
+                os.path.join(project, "Assets", "Audio", f"{name}.wav"), name.encode()
+            )
+        TemplateDeployer.deploy_package(project, components=["audio_event"])
+        results = os.path.join(self.temp_dir, "unity_results.json")
+        editor_dir = os.path.join(project, "Assets", "Editor")
+        os.makedirs(editor_dir, exist_ok=True)
+        with open(
+            os.path.join(editor_dir, "AudioCarrierVerifier.cs"), "w", encoding="utf-8"
+        ) as fh:
+            fh.write(
+                CARRIER_VERIFIER_CS.replace("__FBX__", self.FBX).replace(
+                    "__RESULTS__", results
+                )
+            )
+        log = os.path.join(self.temp_dir, "unity_log.txt")
+        launcher.project_path = project
+        proc = launcher.launch_editor(
+            batch_mode=True,
+            execute_method="AudioCarrierVerifier.Verify",
+            log_file=log,
+            extra_args=["-quit"],
+            detached=False,
+        )
+        returncode = None
+        if proc:
+            try:
+                returncode = proc.wait(timeout=900)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                raise TimeoutError("Unity timed out")
+        UnityEnv.require_results(self, results, returncode, log)
+        with open(results) as fh:
+            unity = json.load(fh)
+        logger.info(f"Unity results:\n{json.dumps(unity, indent=2)}")
+        self.assertNotIn("error", unity, unity.get("error"))
+        self.assertTrue(unity["prefab"], unity)
+        # Premise: both carriers reached the import.
+        self.assertTrue({"data_export", "data_export1"} <= set(unity["nodes"]), unity)
+        self.assertTrue(unity["controller"], unity)
+        self.assertEqual(unity["clips"], ["footstep"], unity)
+
+
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
     unittest.main()

{unitytk-0.2.0 → unitytk-0.2.2}/test/test_embedded_dependencies_integration.py

@@ -38,7 +38,7 @@ import subprocess
 import unittest
 
 import base_test  # noqa: F401 -- sys.path bootstrap for the sibling repos
-from base_test import EnvSkip, MayaEnv, TempProjects, UnityEnv
+from base_test import BlenderEnv, CarrierFbx, EnvSkip, MayaEnv, TempProjects, UnityEnv
 
 from unitytk import TemplateDeployer, UnityFinder, UnityLauncher
 
@@ -456,6 +456,188 @@ class TestEmbeddedDependenciesIntegration(unittest.TestCase):
         self.assertTrue(unity["reexport_still_lightmap"], unity)
 
 
+# ======================================================================
+# When an import asks for the FBX's embedded files to be extracted
+# ======================================================================
+
+REQUEST_VERIFIER_CS = r"""
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+
+public class EmbeddedRequestVerifier
+{
+    static string Q(string s) { return "\"" + (s ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"") + "\""; }
+    static string B(bool b) { return b ? "true" : "false"; }
+
+    static void Finish(List<string> o)
+    {
+        File.WriteAllText(@"__RESULTS__", "{" + string.Join(",\n", o) + "}");
+        EditorApplication.Exit(0);
+    }
+
+    // Session 1: the audio is in the database; the models arrive now.
+    public static void First()
+    {
+        var o = new List<string>();
+        try
+        {
+            foreach (var pair in new[] {
+                new[] { @"__RESOLVED_SRC__", "Assets/Resolved/resolved.fbx" },
+                new[] { @"__GHOSTED_SRC__", "Assets/Ghosted/ghosted.fbx" } })
+            {
+                Directory.CreateDirectory(Path.GetDirectoryName(pair[1]));
+                File.Copy(pair[0], pair[1], true);
+            }
+            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+            o.Add("\"resolved_beside\":" + B(File.Exists("Assets/Resolved/footstep.wav")));
+            var prefab = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Resolved/resolved.fbx");
+            var ctrl = prefab != null ? prefab.GetComponent<AudioEventController>() : null;
+            var clip = ctrl != null && ctrl.clips.Count > 0 ? ctrl.clips[0] : null;
+            o.Add("\"resolved_clip\":" + Q(clip != null ? AssetDatabase.GetAssetPath(clip) : ""));
+            o.Add("\"hit_beside\":" + B(File.Exists("Assets/Ghosted/hit.wav")));
+        }
+        catch (Exception e) { o.Add("\"error\":" + Q(e.GetType().Name + ": " + e.Message)); }
+        Finish(o);
+    }
+
+    // Session 2: hit.wav was touched up beside the model; the model reimports.
+    public static void Second()
+    {
+        var o = new List<string>();
+        try
+        {
+            AssetDatabase.ImportAsset("Assets/Ghosted/ghosted.fbx",
+                ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
+            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+            o.Add("\"touched_kept\":" + B(File.ReadAllBytes("Assets/Ghosted/hit.wav")
+                .SequenceEqual(File.ReadAllBytes(@"__TOUCHED__"))));
+        }
+        catch (Exception e) { o.Add("\"error\":" + Q(e.GetType().Name + ": " + e.Message)); }
+        Finish(o);
+    }
+}
+"""
+
+
+class TestEmbeddedRequestPolicy(unittest.TestCase):
+    """When an import asks for the FBX's embedded files to be extracted
+    beside it (``CarrierImport.RequestEmbeddedFiles``).
+
+    Two ways it overwrote what the user had:
+
+    - a name its importer finds ELSEWHERE (the audio lookup searches
+      ``Assets/Audio``) counted as missing, because only the model's own folder
+      was looked in -- so the whole FBX was extracted and the clip rebound to
+      the copy beside the model;
+    - the memo of what was already asked lived for one editor session, so a
+      model naming a file it does not embed asked again on every session's
+      reimport, and each extraction overwrote the files beside it -- a
+      touched-up clip included.
+
+    The fixture is two real FBXs (``base_test.CarrierFbx``) with their audio
+    embedded as the DCC exporters do (``ptk.FbxMedia.embed``).
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        cls.temp_dir = TempProjects.allocate("embedded_request_policy")
+
+    def _launch(self, launcher, method: str, results: str) -> dict:
+        log = os.path.join(self.temp_dir, f"unity_{method}.txt")
+        proc = launcher.launch_editor(
+            batch_mode=True,
+            execute_method=f"EmbeddedRequestVerifier.{method}",
+            log_file=log,
+            extra_args=["-quit"],
+            detached=False,
+        )
+        returncode = None
+        if proc:
+            try:
+                returncode = proc.wait(timeout=900)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                raise TimeoutError("Unity timed out")
+        UnityEnv.require_results(self, results, returncode, log)
+        with open(results) as fh:
+            unity = json.load(fh)
+        logger.info(f"Unity {method}:\n{json.dumps(unity, indent=2)}")
+        self.assertNotIn("error", unity, unity.get("error"))
+        return unity
+
+    @BlenderEnv.skip_unless_available()
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_found_elsewhere_or_asked_before_is_not_extracted_again(self):
+        import pythontk as ptk
+
+        def manifest(*names):
+            events = [{"clip": "", "frame": 0, "name": n} for n in names]
+            return {"data_export": {"audio_manifest": {"version": 2, "events": events}}}
+
+        staged = os.path.join(self.temp_dir, "staged")
+        os.makedirs(staged)
+        sources = {}
+        for stem, names, embed in (
+            ("resolved", ("footstep",), "footstep"),
+            # "ghost" is embedded nowhere and resolves nowhere: always missing.
+            ("ghosted", ("hit", "ghost"), "hit"),
+        ):
+            bare = CarrierFbx.build(
+                os.path.join(self.temp_dir, f"{stem}_bare.fbx"), manifest(*names)
+            )
+            clip = CarrierFbx.wav(
+                os.path.join(self.temp_dir, "sound", f"{embed}.wav"), b"embedded"
+            )
+            sources[stem] = os.path.join(staged, f"{stem}.fbx")
+            ptk.FbxMedia.embed(bare, sources[stem], files=[(f"{embed}.wav", clip)])
+
+        launcher = UnityLauncher()
+        project = os.path.join(self.temp_dir, "UnityProject")
+        if not launcher.create_project(project, batch_mode=True):
+            self.skipTest(UnityEnv.project_creation_reason())
+        CarrierFbx.wav(
+            os.path.join(project, "Assets", "Audio", "footstep.wav"), b"library"
+        )
+        touched = CarrierFbx.wav(os.path.join(self.temp_dir, "touched.wav"), b"touched")
+        TemplateDeployer.deploy_package(project, components=["audio_event"])
+        results = os.path.join(self.temp_dir, "unity_results.json")
+        editor_dir = os.path.join(project, "Assets", "Editor")
+        os.makedirs(editor_dir, exist_ok=True)
+        with open(
+            os.path.join(editor_dir, "EmbeddedRequestVerifier.cs"),
+            "w",
+            encoding="utf-8",
+        ) as fh:
+            fh.write(
+                REQUEST_VERIFIER_CS.replace("__RESULTS__", results)
+                .replace("__RESOLVED_SRC__", sources["resolved"])
+                .replace("__GHOSTED_SRC__", sources["ghosted"])
+                .replace("__TOUCHED__", touched)
+            )
+        launcher.project_path = project
+
+        first = self._launch(launcher, "First", results)
+        self.assertFalse(
+            first["resolved_beside"],
+            "a clip the lookup finds in Assets/Audio was extracted beside the model",
+        )
+        self.assertEqual(first["resolved_clip"], "Assets/Audio/footstep.wav", first)
+        self.assertTrue(first["hit_beside"], "premise: a missing clip is extracted")
+
+        # The user touches the extracted clip up; the next session reimports.
+        shutil.copy2(touched, os.path.join(project, "Assets", "Ghosted", "hit.wav"))
+        second = self._launch(launcher, "Second", results)
+        self.assertTrue(
+            second["touched_kept"],
+            "a later session's reimport extracted the FBX again over the touched-up "
+            "clip",
+        )
+
+
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
     unittest.main()

{unitytk-0.2.0 → unitytk-0.2.2}/test/test_run_tests.py

@@ -519,8 +519,11 @@ class ChildSettingsSandboxTest(unittest.TestCase):
         with mock.patch.dict(os.environ, env, clear=True):
             UnityTestRunner.sandbox_children(self.root)
             armed = os.environ.copy()
-        # As in a run: TEMP names the run's root, which the stores nest in.
-        armed.update(TEMP=self.root, TMP=self.root, TMPDIR=self.root)
+        # As in a run: TEMP and pythontk's own root (read first, since
+        # pythontk 0.15.0) name the run's root, which the stores nest in.
+        armed.update(
+            TEMP=self.root, TMP=self.root, TMPDIR=self.root, PYTHONTK_TEMP_ROOT=self.root
+        )
         armed.pop("PYTHONTK_TEST_TEMP_ROOT", None)
         scripts = pathlib.Path(__file__).resolve().parents[2]
         armed["PYTHONPATH"] = os.pathsep.join(str(scripts / pkg) for pkg in packages)

{unitytk-0.2.0 → unitytk-0.2.2}/unitytk/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 
 from .launcher import UnityLauncher, UnityFinder
 from .scene_builder import SceneBuilder

{unitytk-0.2.0 → unitytk-0.2.2}/unitytk/asset_delivery.py

@@ -156,7 +156,7 @@ class CopyToAssetsDeliverer(ptk.Deliverer):
             OSError: The copy failed.
         """
         if not ptk.FbxFile.is_fbx(source):
-            shutil.copy2(source, dest)
+            CopyToAssetsDeliverer._place(source, dest)
             return
         hook = getattr(bridge, "lightmap_search_dirs", None)
         try:
@@ -181,10 +181,27 @@ class CopyToAssetsDeliverer(ptk.Deliverer):
                     "exported."
                 )
                 report = None
-            shutil.copy2(staged if report and report["embedded"] else source, dest)
+            CopyToAssetsDeliverer._place(
+                staged if report and report["embedded"] else source, dest
+            )
         finally:
             scratch.cleanup()
 
+    @staticmethod
+    def _place(source: str, dest: str) -> None:
+        """Copy *source* to *dest* whole or not at all.
+
+        Through a ``.part`` beside *dest*, promoted once complete
+        (``ptk.FileUtils.atomic_write``): a copy cut short -- a full disk, a
+        sync client holding the file -- leaves the asset Unity already
+        imported as it was, never a truncated FBX under its name. *source* is
+        only read (it may be the user's own file).
+
+        Raises:
+            OSError: The copy failed; *dest* is untouched.
+        """
+        ptk.FileUtils.atomic_write(dest, lambda part: shutil.copy2(source, part))
+
     @staticmethod
     def sanitize_asset_name(name: str) -> str:
         """Return *name* reduced to a safe Unity asset filename stem.
@@ -273,8 +290,7 @@ class FileToUnityBridge(ptk.HandoffBridge):
     those export a live selection then deliver; this one takes a model already on
     disk. It shares the exact same delivery Strategy -- :class:`CopyToAssetsDeliverer`
     (copy into ``Assets/`` + optional Editor launch) -- so the standalone Unity
-    Workflow panel, the Blender 'Unity Bridge' (which exports the selection to FBX,
-    then hands the path here), a CLI, or a test all reuse one engine.
+    Workflow panel, a CLI, or a test all reuse one engine.
 
     Set :attr:`project_path` to the target Unity project (the folder containing
     ``Assets/``) before calling :meth:`send`::