Replace MEDM in log messages

Author: carlos-villavicencio-adsk

python/tk_multi_loader/dialog.py

@@ -2535,7 +2535,7 @@ def _on_medm_tree_selection_changed(
             # Re-evaluate all proxy filter items
             self._publish_proxy_model.invalidateFilter()
         else:
-            app.log_warning("MEDM: Could not get item from index")
+            app.log_warning("FlowAM: Could not get item from index")
 
 
 ################################################################################################

python/tk_multi_loader/medm/entity_model.py

@@ -236,11 +236,11 @@ def _initialize_project(self) -> None:
             session_project = self._flow_module.data.get_session_project()
             self._project = self._flow_module.data.Project(session_project.id)
             self._app.log_debug(
-                f"MEDM Entity: Initialized project '{self._project.name}'"
+                f"FlowAM Entity: Initialized project '{self._project.name}'"
             )
         except Exception as e:
             self._app.log_error(
-                f"MEDM Entity: Failed to initialize project: {type(e).__name__}: {e}. "
+                f"FlowAM Entity: Failed to initialize project: {type(e).__name__}: {e}. "
                 "Entity tree will not be loaded."
             )
             self._project = None
@@ -273,11 +273,11 @@ def _get_structural_type_ids(self) -> set:
 
             self._structural_type_ids = {folder_id, pipeline_step_id}
             self._app.log_debug(
-                f"MEDM Entity: structural type IDs = {self._structural_type_ids}"
+                f"FlowAM Entity: structural type IDs = {self._structural_type_ids}"
             )
         except self._flow_module.FlowError as e:
             self._app.log_warning(
-                f"MEDM Entity: could not resolve structural type IDs ({e}); "
+                f"FlowAM Entity: could not resolve structural type IDs ({e}); "
                 "non-structural assets without structural descendants will be hidden."
             )
             self._structural_type_ids = set()
@@ -338,13 +338,13 @@ def _load_medm_assets(self) -> None:
         """
         if self._project is None:
             self._app.log_warning(
-                "MEDM Entity: Cannot load assets - project not initialized"
+                "FlowAM Entity: Cannot load assets - project not initialized"
             )
             self.data_refresh_fail.emit("Project not initialized")
             return
 
         try:
-            self._app.log_debug("MEDM: Loading entity tree (project children only)...")
+            self._app.log_debug("FlowAM: Loading entity tree (project children only)...")
 
             count = 0
             for asset in self._project.iterate_children():
@@ -353,13 +353,13 @@ def _load_medm_assets(self) -> None:
                     count += 1
 
             self._app.log_debug(
-                f"MEDM: Entity tree loaded successfully. Loaded {count} root assets"
+                f"FlowAM: Entity tree loaded successfully. Loaded {count} root assets"
             )
             self.cache_loaded.emit()
             self.data_refreshed.emit(True)
 
         except Exception as e:
-            self._app.log_error(f"Failed to load MEDM data: {e}")
+            self._app.log_error(f"Failed to load FlowAM data: {e}")
             import traceback
 
             self._app.log_debug(traceback.format_exc())
@@ -428,11 +428,11 @@ def _load_children_for_item(self, item: QtGui.QStandardItem) -> None:
             for child_asset in tree_children:
                 self._add_asset_item(child_asset, item)
             self._app.log_debug(
-                f"MEDM: Loaded {len(tree_children)}/{len(children)} children for '{asset.name}' "
+                f"FlowAM: Loaded {len(tree_children)}/{len(children)} children for '{asset.name}' "
                 f"(non-structural leaf children hidden from tree)"
             )
         except Exception as e:
-            self._app.log_debug(f"MEDM: Could not get children for '{asset.name}': {e}")
+            self._app.log_debug(f"FlowAM: Could not get children for '{asset.name}': {e}")
 
     def _fetch_and_cache_children(self, asset: Asset) -> List[Asset]:
         """

python/tk_multi_loader/medm/latestpublish_model.py

@@ -119,7 +119,7 @@ def __init__(
         self._current_entity = None
 
         self._project_id = 0
-        self._project_name = "MEDM Project"
+        self._project_name = "FlowAM Project"
         self._initialize_project_info()
 
     # -------------------------------------------------------------------------
@@ -179,7 +179,7 @@ def _initialize_project_info(self) -> None:
             self._project_name = self._app.context.project["name"]
         except Exception as e:
             self._app.log_warning(
-                f"MEDM LatestPublish: Failed to initialize project info: {type(e).__name__}: {e}. "
+                f"FlowAM LatestPublish: Failed to initialize project info: {type(e).__name__}: {e}. "
                 "Using default project values. This may indicate the session project was not "
                 "initialized or the project ID is invalid."
             )
@@ -200,10 +200,10 @@ def _populate_model_from_selected_item(
 
         asset = self._extract_asset_from_tree_item(selected_item)
         if asset is None:
-            self._app.log_warning("MEDM: Could not extract asset from selected item")
+            self._app.log_warning("FlowAM: Could not extract asset from selected item")
             return
 
-        self._app.log_debug(f"MEDM: Asset extracted: {asset.name}")
+        self._app.log_debug(f"FlowAM: Asset extracted: {asset.name}")
 
         children_asset_sg_dicts = self._fetch_asset_children(asset)
 
@@ -218,14 +218,14 @@ def _populate_model_from_selected_item(
                 children_asset_sg_dicts = [self._asset_to_sg_dict(asset)]
             except Exception as e:
                 self._app.log_warning(
-                    f"MEDM: Could not convert leaf asset '{asset.name}' to sg_dict: {e}"
+                    f"FlowAM: Could not convert leaf asset '{asset.name}' to sg_dict: {e}"
                 )
                 # Keep a reference to the raw asset so we can still fetch its
                 # drafts below.
                 leaf_asset_fallback = asset
 
         self._app.log_debug(
-            f"MEDM: Fetched {len(children_asset_sg_dicts)} latest version dicts from children"
+            f"FlowAM: Fetched {len(children_asset_sg_dicts)} latest version dicts from children"
         )
 
         assets_for_draft_lookup = [
@@ -248,7 +248,7 @@ def _populate_model_from_selected_item(
                     self._cache.drafts[child_asset.id] = raw_drafts
             except Exception as e:
                 self._app.log_debug(
-                    f"MEDM: Could not fetch drafts for '{child_asset.name}': {e}"
+                    f"FlowAM: Could not fetch drafts for '{child_asset.name}': {e}"
                 )
                 continue
 
@@ -257,12 +257,12 @@ def _populate_model_from_selected_item(
                 try:
                     draft_dicts.append(self._draft_to_sg_dict(draft_info, child_asset))
                     self._app.log_debug(
-                        f"MEDM: Found draft '{getattr(draft_info, 'name', '?')}' "
+                        f"FlowAM: Found draft '{getattr(draft_info, 'name', '?')}' "
                         f"for asset '{child_asset.name}'"
                     )
                 except Exception as e:
                     self._app.log_warning(
-                        f"MEDM: Could not convert draft '{getattr(draft_info, 'name', '?')}' "
+                        f"FlowAM: Could not convert draft '{getattr(draft_info, 'name', '?')}' "
                         f"for '{child_asset.name}': {e}"
                     )
 
@@ -302,7 +302,7 @@ def _populate_model_from_selected_item(
             draft_count += 1
 
         self._app.log_debug(
-            f"MEDM: center panel now has {self.rowCount()} items "
+            f"FlowAM: center panel now has {self.rowCount()} items "
             f"({draft_count} draft(s), {published_count} published)"
         )
 
@@ -353,27 +353,27 @@ def _fetch_asset_children(self, asset: Asset) -> List[Dict[str, Any]]:
             for child_asset in child_assets:
                 if _is_structural_asset_util(child_asset, self._flow_module):
                     self._app.log_debug(
-                        f"MEDM: Skipping structural asset '{child_asset.name}' from center panel"
+                        f"FlowAM: Skipping structural asset '{child_asset.name}' from center panel"
                     )
                     continue
                 try:
                     asset_dict = self._asset_to_sg_dict(child_asset)
                     children_asset_sg_dicts.append(asset_dict)
                     self._app.log_debug(
-                        f"MEDM: Added asset '{child_asset.name}' with latest version "
+                        f"FlowAM: Added asset '{child_asset.name}' with latest version "
                         f"v{child_asset.version_number}"
                     )
                 except Exception as e:
                     self._app.log_warning(
-                        f"MEDM: Error processing child asset '{child_asset.name}': {e}"
+                        f"FlowAM: Error processing child asset '{child_asset.name}': {e}"
                     )
                     continue
 
         except Exception as e:
-            self._app.log_warning(f"MEDM: Error fetching asset children: {e}")
+            self._app.log_warning(f"FlowAM: Error fetching asset children: {e}")
 
         self._app.log_debug(
-            f"MEDM: Loaded {len(children_asset_sg_dicts)} children assets for asset '{asset.name}'"
+            f"FlowAM: Loaded {len(children_asset_sg_dicts)} children assets for asset '{asset.name}'"
         )
         return children_asset_sg_dicts
 
@@ -385,7 +385,7 @@ def _asset_to_sg_dict(self, asset: Asset) -> Dict[str, Any]:
         :returns: Dictionary with Shotgun-compatible fields
         """
         sg_publish_type_id = None
-        sg_publish_type_code = "MEDM Asset"
+        sg_publish_type_code = "FlowAM Asset"
 
         medm_type_ids = asset.type_ids
         if len(medm_type_ids) > 0:
@@ -404,7 +404,7 @@ def _asset_to_sg_dict(self, asset: Asset) -> Dict[str, Any]:
             "created_by": {
                 "type": "HumanUser",
                 "id": 1,
-                "name": asset.created_by or "MEDM User",
+                "name": asset.created_by or "FlowAM User",
             },
             "entity": {"type": "Asset", "id": None, "name": asset.name},
             "project": {
@@ -453,7 +453,7 @@ def _draft_to_sg_dict(
         :returns: sg_data dictionary compatible with action hooks and center panel UI.
         """
         sg_publish_type_id = None
-        sg_publish_type_code = "MEDM Asset"
+        sg_publish_type_code = "FlowAM Asset"
 
         # Prefer the published asset's type_ids; fall back to the draft's own
         # type_ids for NewDraftInfo where no published asset exists yet.
@@ -524,7 +524,7 @@ def _fetch_new_draft_items_for_parent(
                     draft_type="new"
                 )
             except Exception as e:
-                self._app.log_warning(f"MEDM: Could not fetch new-asset drafts: {e}")
+                self._app.log_warning(f"FlowAM: Could not fetch new-asset drafts: {e}")
                 all_new_drafts = []
             self._cache.drafts[self._NEW_DRAFTS_CACHE_KEY] = all_new_drafts
         else:
@@ -537,13 +537,13 @@ def _fetch_new_draft_items_for_parent(
             try:
                 draft_sg_dict = self._draft_to_sg_dict(draft_info, asset=None)
                 self._app.log_debug(
-                    f"MEDM: Found new-asset draft '{getattr(draft_info, 'name', '?')}' "
+                    f"FlowAM: Found new-asset draft '{getattr(draft_info, 'name', '?')}' "
                     f"under parent '{parent_asset_id}'"
                 )
                 result.append(draft_sg_dict)
             except Exception as e:
                 self._app.log_warning(
-                    f"MEDM: Could not convert new-asset draft "
+                    f"FlowAM: Could not convert new-asset draft "
                     f"'{getattr(draft_info, 'name', '?')}': {e}"
                 )
         return result
@@ -601,7 +601,7 @@ def get_sg_data():
         self.appendRow(qt_item)
 
         self._app.log_debug(
-            f"MEDM: Added item '{qt_item.text()}' to model (row count: {self.rowCount()})"
+            f"FlowAM: Added item '{qt_item.text()}' to model (row count: {self.rowCount()})"
         )
 
     def _set_tooltip(self, item: QtGui.QStandardItem, sg_item: Dict[str, Any]) -> None:

python/tk_multi_loader/medm/publishhistory_model.py

@@ -106,7 +106,7 @@ def __init__(
         self._current_sg_data = None
 
         self._project_id = 0
-        self._project_name = "MEDM Project"
+        self._project_name = "FlowAM Project"
         self._initialize_project_info()
 
     # -------------------------------------------------------------------------
@@ -147,7 +147,7 @@ def load_data(self, sg_data: Dict[str, Any]) -> None:
                 self.data_refreshed.emit(True)
             else:
                 self._app.log_warning(
-                    "MEDM History: No asset found in selected publish asset sg_data dict"
+                    "FlowAM History: No asset found in selected publish asset sg_data dict"
                 )
                 self.data_refresh_fail.emit("No asset found in selection")
             return
@@ -164,7 +164,7 @@ def load_data(self, sg_data: Dict[str, Any]) -> None:
                 self._add_version_as_qt_item(asset_version, medm_asset)
 
             self._app.log_debug(
-                f"MEDM History: Loaded {len(versions)} published versions"
+                f"FlowAM History: Loaded {len(versions)} published versions"
             )
 
             try:
@@ -179,18 +179,18 @@ def load_data(self, sg_data: Dict[str, Any]) -> None:
                     self._add_draft_as_qt_item(draft_info, medm_asset)
                 if drafts:
                     self._app.log_debug(
-                        f"MEDM History: Added {len(drafts)} draft(s) for asset '{medm_asset.name}'"
+                        f"FlowAM History: Added {len(drafts)} draft(s) for asset '{medm_asset.name}'"
                     )
             except Exception as e:
                 # Drafts are optional - a failure here should not prevent published
                 # versions from being shown.
-                self._app.log_warning(f"MEDM History: Could not fetch drafts: {e}")
+                self._app.log_warning(f"FlowAM History: Could not fetch drafts: {e}")
 
             self.cache_loaded.emit()
             self.data_refreshed.emit(True)
 
         except Exception as e:
-            self._app.log_error(f"MEDM History: Error loading versions: {e}")
+            self._app.log_error(f"FlowAM History: Error loading versions: {e}")
             self.data_refresh_fail.emit(str(e))
 
     def async_refresh(self) -> None:
@@ -221,7 +221,7 @@ def _initialize_project_info(self) -> None:
             self._project_name = self._app.context.project["name"]
         except Exception as e:
             self._app.log_warning(
-                f"MEDM History: Failed to initialize project info: {type(e).__name__}: {e}. "
+                f"FlowAM History: Failed to initialize project info: {type(e).__name__}: {e}. "
                 "Using default project values. This may indicate the session project was not "
                 "initialized or the project ID is invalid."
             )
@@ -262,7 +262,7 @@ def get_sg_data():
         qt_item.get_sg_data = get_sg_data
 
         self.appendRow(qt_item)
-        self._app.log_debug(f"MEDM History: Added version v{version_number}")
+        self._app.log_debug(f"FlowAM History: Added version v{version_number}")
 
     def _version_to_sg_dict(
         self, version: AssetVersion, asset: Asset
@@ -275,7 +275,7 @@ def _version_to_sg_dict(
         :returns: sg_data dictionary compatible with Shotgun UI
         """
         sg_publish_type_id = None
-        sg_publish_type_code = "MEDM Asset"
+        sg_publish_type_code = "FlowAM Asset"
 
         medm_type_ids = asset.type_ids
         if medm_type_ids:
@@ -297,7 +297,7 @@ def _version_to_sg_dict(
             "created_by": {
                 "type": "HumanUser",
                 "id": None,
-                "name": version.created_by or "MEDM User",
+                "name": version.created_by or "FlowAM User",
             },
             "entity": {
                 "type": "Asset",
@@ -343,7 +343,7 @@ def _draft_to_sg_dict(
         :returns: sg_data dictionary compatible with action hooks and Shotgun UI
         """
         sg_publish_type_id = None
-        sg_publish_type_code = "MEDM Asset"
+        sg_publish_type_code = "FlowAM Asset"
 
         # Prefer the published asset's type_ids; fall back to the draft's own
         # type_ids for NewDraftInfo where no published asset exists yet.
@@ -414,7 +414,7 @@ def get_sg_data():
         # Prepend so drafts always appear above all published versions.
         self.insertRow(0, qt_item)
         self._app.log_debug(
-            f"MEDM History: Added {draft_type} draft '{draft_info.name}' "
+            f"FlowAM History: Added {draft_type} draft '{draft_info.name}' "
             f"(draft_id={draft_info.draft_id})"
         )
 

python/tk_multi_loader/medm/thumbnail_service.py

@@ -154,7 +154,7 @@ def _resolve_and_fetch(
                 url = self._flow_module.asset_management.get_thumbnail_url(revision_id)
             except Exception as exc:
                 self._app.log_debug(
-                    f"MEDM ThumbnailService: URL resolve failed for {revision_id}: {exc}"
+                    f"FlowAM ThumbnailService: URL resolve failed for {revision_id}: {exc}"
                 )
             self._url_cache[revision_id] = url
 
@@ -178,7 +178,7 @@ def _resolve_and_fetch(
                 ) as response:
                     if response.status != 200:
                         self._app.log_debug(
-                            f"MEDM ThumbnailService: HTTP {response.status} for {revision_id}"
+                            f"FlowAM ThumbnailService: HTTP {response.status} for {revision_id}"
                         )
                         return
                     image_data = response.read(self._MAX_IMAGE_BYTES)
@@ -192,7 +192,7 @@ def _resolve_and_fetch(
 
         except Exception as exc:
             self._app.log_debug(
-                f"MEDM ThumbnailService: Download failed: {type(exc).__name__}: {exc}"
+                f"FlowAM ThumbnailService: Download failed: {type(exc).__name__}: {exc}"
             )
 
     def _process_pending(self) -> None:
@@ -205,5 +205,5 @@ def _process_pending(self) -> None:
                 callback(qt_item, image_data)
             except Exception as exc:
                 self._app.log_debug(
-                    f"MEDM ThumbnailService: Callback error: {type(exc).__name__}: {exc}"
+                    f"FlowAM ThumbnailService: Callback error: {type(exc).__name__}: {exc}"
                 )