{}
".format(item) - } - items.append(message) - else: - message = {"type": "label", "value": "{}
".format(value)} - items.append(message) - - self.show_interface(items, *args, **kwargs) + if isinstance(value, str): + value = [value] + + for item in value: + items.append({"type": "label", "value": f"{item}
"}) + + self.show_interface( + items, + title=title, + user_id=user_id, + user=user, + event=event, + username=username, + submit_btn_label=submit_btn_label + ) def trigger_action( self, - action_identifier, - event=None, - session=None, - selection=None, - user_data=None, - topic="ftrack.action.launch", - additional_event_data={}, - on_error="ignore" + action_identifier: str, + event: Optional[ftrack_api.event.base.Event] = None, + session: Optional[ftrack_api.Session] = None, + selection: Optional[List[Dict[str, str]]] = None, + user_data: Optional[Dict[str, Any]] = None, + topic: Optional[str] = "ftrack.action.launch", + additional_event_data: Optional[Dict[str, Any]] = None, + on_error: Optional[str] = "ignore" ): self.log.debug( "Triggering action \"{}\" Begins".format(action_identifier)) @@ -388,12 +420,12 @@ def trigger_action( def trigger_event( self, - topic, - event_data=None, - session=None, - source=None, - event=None, - on_error="ignore" + topic: str, + event_data: Optional[Dict[str, Any]] = None, + session: Optional[ftrack_api.Session] = None, + source: Optional[Dict[str, Any]] = None, + event: Optional[ftrack_api.event.base.Event] = None, + on_error: Optional[str] = "ignore" ): if session is None: session = self.session @@ -415,7 +447,11 @@ def trigger_event( "Publishing event: {}" ).format(str(event.__dict__))) - def get_project_from_entity(self, entity, session=None): + def get_project_from_entity( + self, + entity: ftrack_api.entity.base.Entity, + session: Optional[ftrack_api.Session] = None + ): low_entity_type = entity.entity_type.lower() if low_entity_type == "project": return entity @@ -449,7 +485,12 @@ def get_project_from_entity(self, entity, session=None): "Project where id is {}".format(project_data["id"]) ).one() - def get_project_entity_from_event(self, session, event, project_id): + def get_project_entity_from_event( + self, + session: ftrack_api.Session, + event: ftrack_api.event.base.Event, + project_id: str, + ): """Load or query and fill project entity from/to event data. Project data are stored by ftrack id because in most cases it is @@ -463,8 +504,8 @@ def get_project_entity_from_event(self, session, event, project_id): Returns: Union[str, None]: Project name based on entities or None if project cannot be defined. - """ + """ if not project_id: raise ValueError( "Entered `project_id` is not valid. {} ({})".format( @@ -486,7 +527,12 @@ def get_project_entity_from_event(self, session, event, project_id): return project_entity - def get_project_name_from_event(self, session, event, project_id): + def get_project_name_from_event( + self, + session: ftrack_api.Session, + event: ftrack_api.event.base.Event, + project_id: str, + ): """Load or query and fill project entity from/to event data. Project data are stored by ftrack id because in most cases it is @@ -500,8 +546,8 @@ def get_project_name_from_event(self, session, event, project_id): Returns: Union[str, None]: Project name based on entities or None if project cannot be defined. - """ + """ if not project_id: raise ValueError( "Entered `project_id` is not valid. {} ({})".format( @@ -522,7 +568,11 @@ def get_project_name_from_event(self, session, event, project_id): project_id_mapping[project_id] = project_name return project_name - def get_ayon_project_from_event(self, event, project_name): + def get_ayon_project_from_event( + self, + event: ftrack_api.event.base.Event, + project_name: str + ): """Get AYON project from event. Args: @@ -531,8 +581,8 @@ def get_ayon_project_from_event(self, event, project_name): Returns: Union[dict[str, Any], None]: AYON project. - """ + """ ayon_projects = event["data"].setdefault("ayon_projects", {}) if project_name in ayon_projects: return ayon_projects[project_name] @@ -543,7 +593,11 @@ def get_ayon_project_from_event(self, event, project_name): ayon_projects[project_name] = project return project - def get_project_settings_from_event(self, event, project_name): + def get_project_settings_from_event( + self, + event: ftrack_api.event.base.Event, + project_name: str + ): """Load or fill AYON's project settings from event data. Project data are stored by ftrack id because in most cases it is @@ -552,8 +606,8 @@ def get_project_settings_from_event(self, event, project_name): Args: event (ftrack_api.Event): Processed event by session. project_name (str): Project name. - """ + """ project_settings_by_name = event["data"].setdefault( "project_settings", {} ) @@ -573,19 +627,21 @@ def get_project_settings_from_event(self, event, project_name): return copy.deepcopy(project_settings) @staticmethod - def get_entity_path(entity): + def get_entity_path(entity: ftrack_api.entity.base.Entity) -> str: """Return full hierarchical path to entity.""" - return "/".join( [ent["name"] for ent in entity["link"]] ) @classmethod def add_traceback_to_job( - cls, job, session, exc_info, - description=None, - component_name=None, - job_status=None + cls, + job: ftrack_api.entity.job.Job, + session: ftrack_api.Session, + exc_info: Tuple, + description: Optional[str] = None, + component_name: Optional[str] = None, + job_status: Optional[str] = None ): """Add traceback file to a job. @@ -602,8 +658,8 @@ def add_traceback_to_job( not specified. job_status (str): Status of job which will be set. By default is set to 'failed'. - """ + """ if description: job_data = { "description": description @@ -639,7 +695,12 @@ def add_traceback_to_job( os.remove(temp_filepath) @staticmethod - def add_file_component_to_job(job, session, filepath, basename=None): + def add_file_component_to_job( + job: ftrack_api.entity.job.Job, + session: ftrack_api.Session, + filepath: str, + basename: Optional[str] = None + ): """Add filepath as downloadable component to job. Args: @@ -652,8 +713,8 @@ def add_file_component_to_job(job, session, filepath, basename=None): user's side. Must be without extension otherwise extension will be duplicated in downloaded name. Basename from entered path used when not entered. - """ + """ # Make sure session's locations are configured # - they can be deconfigured e.g. using `rollback` method session._configure_locations() diff --git a/client/ayon_ftrack/common/event_handlers/ftrack_event_handler.py b/client/ayon_ftrack/common/event_handlers/ftrack_event_handler.py index b8a9c726..bd4ae326 100644 --- a/client/ayon_ftrack/common/event_handlers/ftrack_event_handler.py +++ b/client/ayon_ftrack/common/event_handlers/ftrack_event_handler.py @@ -1,3 +1,7 @@ +from typing import Optional + +import ftrack_api + from .ftrack_base_handler import BaseHandler @@ -9,32 +13,34 @@ class BaseEventHandler(BaseHandler): By default is listening to "ftrack.update". To change it override 'register' method of change 'subscription_topic' attribute. """ + __ignore_handler_class: bool = True - subscription_topic = "ftrack.update" - handler_type = "Event" + subscription_topic: str = "ftrack.update" + handler_type: str = "Event" def register(self): """Register to subscription topic.""" - self.session.event_hub.subscribe( "topic={}".format(self.subscription_topic), self._process, priority=self.priority ) - def process(self, event): + def process(self, event: ftrack_api.event.base.Event): """Callback triggered on event with matching topic. Args: - session (ftrack_api.Session): Ftrack session which triggered - the event. event (ftrack_api.Event): Ftrack event to process. - """ + """ return self.launch(self.session, event) - def launch(self, session, event): + def launch( + self, + session: ftrack_api.Session, + event: ftrack_api.event.base.Event + ): """Deprecated method used for backwards compatibility. Override 'process' method rather then 'launch'. Method name 'launch' @@ -45,19 +51,18 @@ def launch(self, session, event): session (ftrack_api.Session): Ftrack session which triggered the event. event (ftrack_api.Event): Ftrack event to process. - """ + """ raise NotImplementedError() - def _process(self, event): + def _process(self, event: ftrack_api.event.base.Event): return self._launch(event) - def _launch(self, event): + def _launch(self, event: ftrack_api.event.base.Event): """Callback kept for backwards compatibility. Will be removed when default """ - self.session.rollback() self.session._local_cache.clear() @@ -65,16 +70,20 @@ def _launch(self, event): self.process(event) except Exception as exc: - self.session.rollback() - self.session._configure_locations() self.log.error( "Event \"{}\" Failed: {}".format( self.__class__.__name__, str(exc) ), exc_info=True ) + self.session.rollback() + self.session._configure_locations() - def _translate_event(self, event, session=None): + def _translate_event( + self, + event: ftrack_api.event.base.Event, + session: Optional[ftrack_api.Session] = None + ): """Receive entity objects based on event. Args: @@ -83,8 +92,8 @@ def _translate_event(self, event, session=None): Returns: List[ftrack_api.Entity]: Queried entities based on event data. - """ + """ return self._get_entities( event, session, diff --git a/client/ayon_ftrack/common/ftrack_server.py b/client/ayon_ftrack/common/ftrack_server.py index 0e47abac..58c64108 100644 --- a/client/ayon_ftrack/common/ftrack_server.py +++ b/client/ayon_ftrack/common/ftrack_server.py @@ -3,46 +3,127 @@ import logging import traceback import types +import inspect import ftrack_api from .python_module_tools import modules_from_path +from .event_handlers import BaseHandler class FtrackServer: + """Helper wrapper to run ftrack server with event handlers. + + Handlers are discovered based on a list of paths. Each path is scanned for + python files which are imported as modules. Each module is checked for + 'register' function or classes inheriting from 'BaseHandler'. If class + inheriting from 'BaseHandler' is found it is instantiated and 'register' + method is called. If 'register' function is found it is called with + ftrack session as argument and 'BaseHandler' from the file are ignored. + + Function 'register' tells discovery system to skip looking for classes. + + Classes that start with '_' are ignored. It is possible to define + attribute `__ignore_handler_class = True` on class definition to mark + a "base class" that will be ignored on discovery, so you can safely import + custom base classes in the files. + """ def __init__(self, handler_paths=None): - """ - - 'type' is by default set to 'action' - Runs Action server - - enter 'event' for Event server - - EXAMPLE FOR EVENT SERVER: - ... - server = FtrackServer() - server.run_server() - .. - """ - # set Ftrack logging to Warning only - OPTIONAL ftrack_log = logging.getLogger("ftrack_api") ftrack_log.setLevel(logging.WARNING) self.log = logging.getLogger(__name__) - self.stopped = True - self.is_running = False + self._stopped = True + self._is_running = False + + if handler_paths is None: + handler_paths = [] - self.handler_paths = handler_paths or [] + self._handler_paths = handler_paths + + self._session = None + self._cached_modules = [] + self._cached_objects = [] def stop_session(self): - self.stopped = True - if self.session.event_hub.connected is True: - self.session.event_hub.disconnect() - self.session.close() - self.session = None + session = self._session + self._session = None + self._stopped = True + if session.event_hub.connected is True: + session.event_hub.disconnect() + session.close() - def set_files(self, paths): - # Iterate all paths + def get_session(self): + return self._session + + def get_handler_paths(self): + return self._handler_paths + + def set_handler_paths(self, paths): + if self._is_running: + raise ValueError( + "Cannot change handler paths when server is running." + ) + self._handler_paths = paths + + session = property(get_session) + handler_paths = property(get_handler_paths, set_handler_paths) + + def run_server(self, session=None): + if self._is_running: + raise ValueError("Server is already running.") + self._stopped = False + self._is_running = True + if not session: + session = ftrack_api.Session(auto_connect_event_hub=True) + + # Wait until session has connected event hub + if session._auto_connect_event_hub_thread: + # Use timeout from session (since ftrack-api 2.1.0) + timeout = getattr(session, "request_timeout", 60) + self.log.info("Waiting for event hub to connect") + started = time.time() + while not session.event_hub.connected: + if (time.time() - started) > timeout: + raise RuntimeError(( + "Connection to Ftrack was not created in {} seconds" + ).format(timeout)) + time.sleep(0.1) + + elif not session.event_hub.connected: + self.log.info("Connecting event hub") + session.event_hub.connect() + + self._session = session + if not self._handler_paths: + self.log.warning(( + "Paths to event handlers are not set." + " Ftrack server won't launch." + )) + self._is_running = False + return + + self._load_handlers() + + msg = "Registration of event handlers has finished!" + self.log.info(len(msg) * "*") + self.log.info(msg) + + # keep event_hub on session running + try: + session.event_hub.wait() + finally: + self._is_running = False + self._cached_modules = [] + + def _load_handlers(self): register_functions = [] + handler_classes = [] + + # Iterate all paths + paths = self._handler_paths for path in paths: # Try to format path with environments try: @@ -58,88 +139,72 @@ def set_files(self, paths): )) for filepath, module in modules: - register_function = None - for name, attr in module.__dict__.items(): + self._cached_modules.append(module) + register_function = getattr(module, "register", None) + if register_function is not None: + if isinstance(register_function, types.FunctionType): + register_functions.append( + (filepath, register_function) + ) + else: + self.log.warning( + f"\"{filepath}\"" + " - Found 'register' but it is not a function." + ) + continue + + for attr_name in dir(module): + if attr_name.startswith("_"): + self.log.debug( + f"Skipping private class '{attr_name}'" + ) + continue + + attr = getattr(module, attr_name, None) if ( - name == "register" - and isinstance(attr, types.FunctionType) + not inspect.isclass(attr) + or not issubclass(attr, BaseHandler) + or attr.ignore_handler_class() ): - register_function = attr - break + continue + + if inspect.isabstract(attr): + self.log.warning( + f"Skipping abstract class '{attr_name}'." + ) + continue + handler_classes.append(attr) - if not register_function: + if not handler_classes: self.log.warning( - "\"{}\" - Missing register method".format(filepath) + f"\"{filepath}\"" + " - No 'register' function" + " or 'BaseHandler' classes found." ) - continue - - register_functions.append( - (filepath, register_function) - ) - if not register_functions: + if not register_functions and not handler_classes: self.log.warning(( - "There are no events with `register` function" - " in registered paths: \"{}\"" - ).format("| ".join(paths))) + "There are no files with `register` function or 'BaseHandler'" + " classes in registered paths:\n- \"{}\"" + ).format("- \n".join(paths))) for filepath, register_func in register_functions: try: - register_func(self.session) + register_func(self._session) except Exception: self.log.warning( - "\"{}\" - register was not successful".format(filepath), + f"\"{filepath}\" - register was not successful", exc_info=True ) - def set_handler_paths(self, paths): - self.handler_paths = paths - if self.is_running: - self.stop_session() - self.run_server() - - elif not self.stopped: - self.run_server() - - def run_server(self, session=None, load_files=True): - self.stopped = False - self.is_running = True - if not session: - session = ftrack_api.Session(auto_connect_event_hub=True) - - # Wait until session has connected event hub - if session._auto_connect_event_hub_thread: - # Use timeout from session (since ftrack-api 2.1.0) - timeout = getattr(session, "request_timeout", 60) - self.log.info("Waiting for event hub to connect") - started = time.time() - while not session.event_hub.connected: - if (time.time() - started) > timeout: - raise RuntimeError(( - "Connection to Ftrack was not created in {} seconds" - ).format(timeout)) - time.sleep(0.1) - - elif not session.event_hub.connected: - self.log.info("Connecting event hub") - session.event_hub.connect() - - self.session = session - if load_files: - if not self.handler_paths: - self.log.warning(( - "Paths to event handlers are not set." - " Ftrack server won't launch." - )) - self.is_running = False - return - - self.set_files(self.handler_paths) - - msg = "Registration of event handlers has finished!" - self.log.info(len(msg) * "*") - self.log.info(msg) + for handler_class in handler_classes: + try: + obj = handler_class(self._session) + obj.register() + self._cached_objects.append(obj) - # keep event_hub on session running - self.session.event_hub.wait() - self.is_running = False + except Exception: + self.log.warning( + f"\"{handler_class}\" - register was not successful", + exc_info=True + ) diff --git a/client/ayon_ftrack/common/utils.py b/client/ayon_ftrack/common/utils.py index a94c8b18..5cce573d 100644 --- a/client/ayon_ftrack/common/utils.py +++ b/client/ayon_ftrack/common/utils.py @@ -84,7 +84,7 @@ def get_datetime_data(datetime_obj=None): """Returns current datetime data as dictionary. Note: - This function is copied from 'openpype.lib'. + This function is copied from 'ayon_core.lib'. Args: datetime_obj (datetime): Specific datetime object diff --git a/client/ayon_ftrack/event_handlers_to_convert/action_delete_old_versions.py b/client/ayon_ftrack/event_handlers_to_convert/action_delete_old_versions.py index 7c8dc9bd..a0e3c84a 100644 --- a/client/ayon_ftrack/event_handlers_to_convert/action_delete_old_versions.py +++ b/client/ayon_ftrack/event_handlers_to_convert/action_delete_old_versions.py @@ -3,20 +3,21 @@ import uuid import clique -from pymongo import UpdateOne -from openpype.client import ( - get_assets, - get_subsets, +from ayon_api import ( + get_folders, + get_products, get_versions, - get_representations + get_representations, ) -from openpype.lib import ( +from ayon_api.operations import OperationsSession + +from ayon_core.lib import ( StringTemplate, TemplateUnsolved, format_file_size, ) -from openpype.pipeline import AvalonMongoDB, Anatomy +from ayon_core.pipeline import Anatomy from ayon_ftrack.common import LocalAction from ayon_ftrack.lib import get_ftrack_icon_url @@ -34,8 +35,6 @@ class DeleteOldVersions(LocalAction): settings_key = "delete_old_versions" - dbcon = AvalonMongoDB() - inteface_title = "Choose your preferences" splitter_item = {"type": "label", "value": "---"} sequence_splitter = "__sequence_splitter__" @@ -161,12 +160,10 @@ def launch(self, session, entities, event): " and will keep {1} latest version{2}." ).format(_val1, versions_count, _val3)) - self.dbcon.install() - project = None - avalon_asset_names = [] + folder_paths = [] asset_versions_by_parent_id = collections.defaultdict(list) - subset_names_by_asset_name = collections.defaultdict(list) + product_names_by_folder_path = collections.defaultdict(list) ftrack_assets_by_name = {} for entity in entities: @@ -174,10 +171,13 @@ def launch(self, session, entities, event): parent_ent = ftrack_asset["parent"] parent_ftrack_id = parent_ent["id"] - parent_name = parent_ent["name"] - if parent_name not in avalon_asset_names: - avalon_asset_names.append(parent_name) + path_items = [item["name"] for item in entity["link"]] + path_items[0] = "" + folder_path = "/".join(path_items) + + if folder_path not in folder_paths: + folder_paths.append(folder_path) # Group asset versions by parent entity asset_versions_by_parent_id[parent_ftrack_id].append(entity) @@ -186,101 +186,93 @@ def launch(self, session, entities, event): if project is None: project = parent_ent["project"] - # Collect subset names per asset - subset_name = ftrack_asset["name"] - subset_names_by_asset_name[parent_name].append(subset_name) + # Collect product names per asset + product_name = ftrack_asset["name"] + product_names_by_folder_path[folder_path].append(product_name) - if subset_name not in ftrack_assets_by_name: - ftrack_assets_by_name[subset_name] = ftrack_asset + if product_name not in ftrack_assets_by_name: + ftrack_assets_by_name[product_name] = ftrack_asset # Set Mongo collection project_name = project["full_name"] anatomy = Anatomy(project_name) - self.dbcon.Session["AVALON_PROJECT"] = project_name self.log.debug("Project is set to {}".format(project_name)) - # Get Assets from avalon database - assets = list( - get_assets(project_name, asset_names=avalon_asset_names) - ) - asset_id_to_name_map = { - asset["_id"]: asset["name"] for asset in assets + # Fetch folders + folder_path_by_id = { + folder_entity["id"]: folder_entity["path"] + for folder_entity in get_folders( + project_name, folder_paths=folder_paths + ) } - asset_ids = list(asset_id_to_name_map.keys()) + folder_ids = set(folder_path_by_id.keys()) - self.log.debug("Collected assets ({})".format(len(asset_ids))) + self.log.debug("Collected assets ({})".format(len(folder_ids))) - # Get Subsets - subsets = list( - get_subsets(project_name, asset_ids=asset_ids) - ) - subsets_by_id = {} - subset_ids = [] - for subset in subsets: - asset_id = subset["parent"] - asset_name = asset_id_to_name_map[asset_id] - available_subsets = subset_names_by_asset_name[asset_name] - - if subset["name"] not in available_subsets: - continue + # Get product entities + product_entities_by_id = { + product_entity["id"]: product_entity + for product_entity in get_products( + project_name, folder_ids=folder_ids + ) + } + # Filter products by available product names + for product_entity in product_entities_by_id.values(): + folder_id = product_entity["folderId"] + folder_path = folder_path_by_id[folder_id] - subset_ids.append(subset["_id"]) - subsets_by_id[subset["_id"]] = subset + available_products = product_names_by_folder_path[folder_path] + if product_entity["name"] not in available_products: + product_id = product_entity["id"] + product_entities_by_id.pop(product_id) - self.log.debug("Collected subsets ({})".format(len(subset_ids))) + product_ids = set(product_entities_by_id.keys()) + + self.log.debug("Collected products ({})".format(len(product_ids))) # Get Versions - versions = list( - get_versions(project_name, subset_ids=subset_ids) - ) + version_entities_by_id = { + version_entity["id"]: version_entity + for version_entity in get_versions( + project_name, + product_ids=product_ids, + hero=False, + active=None + ) + } + # Store all versions by product id even inactive entities versions_by_parent = collections.defaultdict(list) - for ent in versions: - versions_by_parent[ent["parent"]].append(ent) + for version_entity in version_entities_by_id.values(): + product_id = version_entity["productId"] + versions_by_parent[product_id].append(version_entity) def sort_func(ent): - return int(ent["name"]) + return ent["version"] - all_last_versions = [] - for parent_id, _versions in versions_by_parent.items(): - for idx, version in enumerate( - sorted(_versions, key=sort_func, reverse=True) + # Filter latest versions + for parent_id, version_entities in versions_by_parent.items(): + for idx, version_entity in enumerate( + sorted(version_entities, key=sort_func, reverse=True) ): if idx >= versions_count: break - all_last_versions.append(version) + version_entities_by_id.pop(version_entity["id"]) - self.log.debug("Collected versions ({})".format(len(versions))) - - # Filter latest versions - for version in all_last_versions: - versions.remove(version) + self.log.debug( + "Collected versions ({})".format(len(version_entities_by_id)) + ) # Update versions_by_parent without filtered versions versions_by_parent = collections.defaultdict(list) - for ent in versions: - versions_by_parent[ent["parent"]].append(ent) - - # Filter already deleted versions - versions_to_pop = [] - for version in versions: - version_tags = version["data"].get("tags") - if version_tags and "deleted" in version_tags: - versions_to_pop.append(version) - - for version in versions_to_pop: - subset = subsets_by_id[version["parent"]] - asset_id = subset["parent"] - asset_name = asset_id_to_name_map[asset_id] - msg = "Asset: \"{}\" | Subset: \"{}\" | Version: \"{}\"".format( - asset_name, subset["name"], version["name"] - ) - self.log.warning(( - "Skipping version. Already tagged as `deleted`. < {} >" - ).format(msg)) - versions.remove(version) + for version_entity in version_entities_by_id.values(): + # Filter already deactivated versions + if not version_entity["active"]: + continue + product_id = version_entity["productId"] + versions_by_parent[product_id].append(version_entity) - version_ids = [ent["_id"] for ent in versions] + version_ids = set(version_entities_by_id.keys()) self.log.debug( "Filtered versions to delete ({})".format(len(version_ids)) @@ -294,22 +286,26 @@ def sort_func(ent): "message": msg } - repres = list( + repre_entities = list( get_representations(project_name, version_ids=version_ids) ) self.log.debug( - "Collected representations to remove ({})".format(len(repres)) + "Collected representations to remove ({})".format( + len(repre_entities) + ) ) dir_paths = {} file_paths_by_dir = collections.defaultdict(list) - for repre in repres: - file_path, seq_path = self.path_from_represenation(repre, anatomy) + for repre_entity in repre_entities: + file_path, seq_path = self.path_from_represenation( + repre_entity, anatomy + ) if file_path is None: self.log.warning(( "Could not format path for represenation \"{}\"" - ).format(str(repre))) + ).format(str(repre_entity))) continue dir_path = os.path.dirname(file_path) @@ -345,8 +341,6 @@ def sort_func(ent): ).format(paths_msg)) # Size of files. - size = 0 - if only_calculate: if force_to_remove: size = self.delete_whole_dir_paths( @@ -368,44 +362,33 @@ def sort_func(ent): else: size = self.delete_only_repre_files(dir_paths, file_paths_by_dir) - mongo_changes_bulk = [] - for version in versions: - orig_version_tags = version["data"].get("tags") or [] - version_tags = [tag for tag in orig_version_tags] - if "deleted" not in version_tags: - version_tags.append("deleted") - - if version_tags == orig_version_tags: - continue - - update_query = {"_id": version["_id"]} - update_data = {"$set": {"data.tags": version_tags}} - mongo_changes_bulk.append(UpdateOne(update_query, update_data)) - - if mongo_changes_bulk: - self.dbcon.bulk_write(mongo_changes_bulk) + op_session = OperationsSession() + for version_entity in version_entities_by_id.values(): + op_session.update_entity( + project_name, + "version", + version_entity["id"], + {"active": False} + ) - self.dbcon.uninstall() + op_session.commit() # Set attribute `is_published` to `False` on ftrack AssetVersions - for subset_id, _versions in versions_by_parent.items(): - subset_name = None - for subset in subsets: - if subset["_id"] == subset_id: - subset_name = subset["name"] - break - - if subset_name is None: + for product_id, _versions in versions_by_parent.items(): + product_entity = product_entities_by_id.get(product_id) + if product_entity is None: self.log.warning( - "Subset with ID `{}` was not found.".format(str(subset_id)) + "Product with ID `{}` was not found.".format(str(product_id)) ) continue - ftrack_asset = ftrack_assets_by_name.get(subset_name) + product_name = product_entity["name"] + + ftrack_asset = ftrack_assets_by_name.get(product_name) if not ftrack_asset: self.log.warning(( "Could not find Ftrack asset with name `{}`" - ).format(subset_name)) + ).format(product_name)) continue version_numbers = [int(ver["name"]) for ver in _versions] @@ -576,9 +559,3 @@ def path_from_represenation(self, representation, anatomy): return (None, None) return (os.path.normpath(path), sequence_path) - - -def register(session): - '''Register plugin. Called when used as an plugin.''' - - DeleteOldVersions(session).register() diff --git a/client/ayon_ftrack/event_handlers_to_convert/action_djvview.py b/client/ayon_ftrack/event_handlers_to_convert/action_djvview.py deleted file mode 100644 index 3ac14d72..00000000 --- a/client/ayon_ftrack/event_handlers_to_convert/action_djvview.py +++ /dev/null @@ -1,239 +0,0 @@ -import os -import time -import subprocess -from operator import itemgetter -from openpype.lib import ApplicationManager -from ayon_ftrack.common import LocalAction -from ayon_ftrack.lib import statics_icon - - -class DJVViewAction(LocalAction): - """Launch DJVView action.""" - identifier = "djvview-launch-action" - label = "DJV View" - description = "DJV View Launcher" - icon = statics_icon("app_icons", "djvView.png") - - type = "Application" - - allowed_types = [ - "cin", "dpx", "avi", "dv", "gif", "flv", "mkv", "mov", "mpg", "mpeg", - "mp4", "m4v", "mxf", "iff", "z", "ifl", "jpeg", "jpg", "jfif", "lut", - "1dl", "exr", "pic", "png", "ppm", "pnm", "pgm", "pbm", "rla", "rpf", - "sgi", "rgba", "rgb", "bw", "tga", "tiff", "tif", "img" - ] - - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - - self.application_manager = ApplicationManager() - self._last_check = time.time() - self._check_interval = 10 - - def _get_djv_apps(self): - app_group = self.application_manager.app_groups["djvview"] - - output = [] - for app in app_group: - executable = app.find_executable() - if executable is not None: - output.append(app) - return output - - def get_djv_apps(self): - cur_time = time.time() - if (cur_time - self._last_check) > self._check_interval: - self.application_manager.refresh() - return self._get_djv_apps() - - def discover(self, session, entities, event): - """Return available actions based on *event*. """ - selection = event["data"].get("selection", []) - if len(selection) != 1: - return False - - entityType = selection[0].get("entityType", None) - if entityType not in ["assetversion", "task"]: - return False - - if self.get_djv_apps(): - return True - return False - - def interface(self, session, entities, event): - if event["data"].get("values", {}): - return - - entity = entities[0] - versions = [] - - entity_type = entity.entity_type.lower() - if entity_type == "assetversion": - if ( - entity[ - "components" - ][0]["file_type"][1:] in self.allowed_types - ): - versions.append(entity) - else: - master_entity = entity - if entity_type == "task": - master_entity = entity["parent"] - - for asset in master_entity["assets"]: - for version in asset["versions"]: - # Get only AssetVersion of selected task - if ( - entity_type == "task" and - version["task"]["id"] != entity["id"] - ): - continue - # Get only components with allowed type - filetype = version["components"][0]["file_type"] - if filetype[1:] in self.allowed_types: - versions.append(version) - - if len(versions) < 1: - return { - "success": False, - "message": "There are no Asset Versions to open." - } - - # TODO sort them (somehow?) - enum_items = [] - first_value = None - for app in self.get_djv_apps(): - if first_value is None: - first_value = app.full_name - enum_items.append({ - "value": app.full_name, - "label": app.full_label - }) - - if not enum_items: - return { - "success": False, - "message": "Couldn't find DJV executable." - } - - items = [ - { - "type": "enumerator", - "label": "DJV version:", - "name": "djv_app_name", - "data": enum_items, - "value": first_value - }, - { - "type": "label", - "value": "---" - } - ] - version_items = [] - base_label = "v{0} - {1} - {2}" - default_component = None - last_available = None - select_value = None - for version in versions: - for component in version["components"]: - label = base_label.format( - str(version["version"]).zfill(3), - version["asset"]["type"]["name"], - component["name"] - ) - - try: - location = component[ - "component_locations" - ][0]["location"] - file_path = location.get_filesystem_path(component) - except Exception: - file_path = component[ - "component_locations" - ][0]["resource_identifier"] - - if os.path.isdir(os.path.dirname(file_path)): - last_available = file_path - if component["name"] == default_component: - select_value = file_path - version_items.append( - {"label": label, "value": file_path} - ) - - if len(version_items) == 0: - return { - "success": False, - "message": ( - "There are no Asset Versions with accessible path." - ) - } - - item = { - "label": "Items to view", - "type": "enumerator", - "name": "path", - "data": sorted( - version_items, - key=itemgetter("label"), - reverse=True - ) - } - if select_value is not None: - item["value"] = select_value - else: - item["value"] = last_available - - items.append(item) - - return {"items": items} - - def launch(self, session, entities, event): - """Callback method for DJVView action.""" - - # Launching application - event_values = event["data"].get("value") - if not event_values: - return - - djv_app_name = event_values["djv_app_name"] - app = self.application_manager.applications.get(djv_app_name) - executable = None - if app is not None: - executable = app.find_executable() - - if not executable: - return { - "success": False, - "message": "Couldn't find DJV executable." - } - - filpath = os.path.normpath(event_values["path"]) - - cmd = [ - # DJV path - str(executable), - # PATH TO COMPONENT - filpath - ] - - try: - # Run DJV with these commands - _process = subprocess.Popen(cmd) - # Keep process in memory for some time - time.sleep(0.1) - - except FileNotFoundError: - return { - "success": False, - "message": "File \"{}\" was not found.".format( - os.path.basename(filpath) - ) - } - - return True - - -def register(session): - """Register hooks.""" - - DJVViewAction(session).register() diff --git a/client/ayon_ftrack/event_handlers_to_convert/action_fill_workfile_attr.py b/client/ayon_ftrack/event_handlers_to_convert/action_fill_workfile_attr.py index 1488d160..0e6c892c 100644 --- a/client/ayon_ftrack/event_handlers_to_convert/action_fill_workfile_attr.py +++ b/client/ayon_ftrack/event_handlers_to_convert/action_fill_workfile_attr.py @@ -6,16 +6,17 @@ import datetime import ftrack_api - -from openpype.client import ( +from ayon_api import ( get_project, - get_assets, + get_folders, + get_tasks, ) -from openpype.settings import get_project_settings, get_system_settings -from openpype.lib import StringTemplate -from openpype.pipeline import Anatomy -from openpype.pipeline.template_data import get_template_data -from openpype.pipeline.workfile import get_workfile_template_key + +from ayon_core.settings import get_project_settings +from ayon_core.lib import StringTemplate +from ayon_core.pipeline import Anatomy +from ayon_core.pipeline.template_data import get_template_data +from ayon_core.pipeline.workfile import get_workfile_template_key from ayon_ftrack.common import LocalAction, create_chunks from ayon_ftrack.lib import get_ftrack_icon_url @@ -53,13 +54,13 @@ def discover(self, session, entities, event): def launch(self, session, entities, event): # Separate entities and get project entity - project_entity = None + ft_project_entity = None for entity in entities: - if project_entity is None: - project_entity = self.get_project_from_entity(entity) + if ft_project_entity is None: + ft_project_entity = self.get_project_from_entity(entity) break - if not project_entity: + if not ft_project_entity: return { "message": ( "Couldn't find project entity." @@ -70,7 +71,7 @@ def launch(self, session, entities, event): # Get project settings and check if custom attribute where workfile # should be set is defined. - project_name = project_entity["full_name"] + project_name = ft_project_entity["full_name"] project_settings = get_project_settings(project_name) custom_attribute_key = ( project_settings @@ -132,7 +133,7 @@ def launch(self, session, entities, event): session, entities, job_entity, - project_entity, + ft_project_entity, project_settings, attr_conf, report @@ -225,12 +226,12 @@ def in_job_process( session, entities, job_entity, - project_entity, + ft_project_entity, project_settings, attr_conf, report ): - task_entities = [] + ft_task_entities = [] other_entities = [] project_selected = False for entity in entities: @@ -240,31 +241,49 @@ def in_job_process( break elif ent_type_low == "task": - task_entities.append(entity) + ft_task_entities.append(entity) else: other_entities.append(entity) - project_name = project_entity["full_name"] + project_name = ft_project_entity["full_name"] # Find matchin asset documents and map them by ftrack task entities - # - result stored to 'asset_docs_with_task_entities' is list with - # tuple `(asset document, [task entitis, ...])` - # Quety all asset documents - asset_docs = list(get_assets(project_name)) + # - result stored to 'folder_entities_with_ft_task_entities' is list + # with a tuple `(folder entity, [ftrack task entitis, ...])` + # Fetch all folder and task entities + folder_entities = list(get_folders( + project_name, fields={"id", "folderType", "path", "attrib"} + )) + task_entities_by_folder_id = collections.defaultdict(list) + for task_entity in get_tasks( + project_name, fields={"id", "taskType", "name", "folderId"} + ): + folder_id = task_entity["folderId"] + task_entities_by_folder_id[folder_id].append(task_entity) + job_entity["data"] = json.dumps({ - "description": "(1/3) Asset documents queried." + "description": "(1/3) Folder & Task entities queried." }) session.commit() # When project is selected then we can query whole project if project_selected: - asset_docs_with_task_entities = self._get_asset_docs_for_project( - session, project_entity, asset_docs, report + folder_entities_with_ft_task_entities = self._get_asset_docs_for_project( + session, + ft_project_entity, + folder_entities, + task_entities_by_folder_id, + report ) else: - asset_docs_with_task_entities = self._get_tasks_for_selection( - session, other_entities, task_entities, asset_docs, report + folder_entities_with_ft_task_entities = self._get_tasks_for_selection( + session, + other_entities, + ft_task_entities, + folder_entities, + task_entities_by_folder_id, + report ) job_entity["data"] = json.dumps({ @@ -275,27 +294,50 @@ def in_job_process( # Keep placeholders in the template unfilled host_name = "{app}" extension = "{ext}" - project_doc = get_project(project_name) + project_entity = get_project(project_name) project_settings = get_project_settings(project_name) - system_settings = get_system_settings() anatomy = Anatomy(project_name) templates_by_key = {} operations = [] - for asset_doc, task_entities in asset_docs_with_task_entities: - for task_entity in task_entities: + for folder_entity, ft_task_entities in folder_entities_with_ft_task_entities: + folder_id = folder_entity["id"] + folder_path = folder_entity["path"] + task_entities_by_name = { + task_entity["name"]: task_entity + for task_entity in task_entities_by_folder_id[folder_id] + } + task_entities_by_low_name = { + name.lower(): task_entity + for name, task_entity in task_entities_by_name.items() + } + for ft_task_entity in ft_task_entities: + task_name = ft_task_entity["name"] + task_entity = task_entities_by_name.get(task_name) + if not task_entity: + task_entity = task_entities_by_low_name.get( + task_name.lower() + ) + + if not task_entity: + self.log.warning( + f"Coulnd't find task entity \"{task_name}\"" + f" for folder \"{folder_path}\"" + ) + continue + workfile_data = get_template_data( - project_doc, - asset_doc, - task_entity["name"], + project_entity, + folder_entity, + task_entity, host_name, - system_settings + project_settings ) # Use version 1 for each workfile workfile_data["version"] = 1 workfile_data["ext"] = extension - task_type = workfile_data["task"]["type"] + task_type = task_entity["taskType"] template_key = get_workfile_template_key( task_type, host_name, @@ -317,7 +359,7 @@ def in_job_process( else: table_values = collections.OrderedDict(( ("configuration_id", attr_conf["id"]), - ("entity_id", task_entity["id"]) + ("entity_id", ft_task_entity["id"]) )) operations.append( ftrack_api.operation.UpdateEntityOperation( @@ -348,145 +390,151 @@ def _get_entity_path(self, entity): return "/".join(path_items) def _get_asset_docs_for_project( - self, session, project_entity, asset_docs, report + self, + session, + ft_project_entity, + folder_entities, + task_entities_by_folder_id, + report, ): - asset_docs_task_names = {} - - for asset_doc in asset_docs: - asset_data = asset_doc["data"] - ftrack_id = asset_data.get("ftrackId") + folder_entity_task_names = {} + for folder_entity in folder_entities: + ftrack_id = folder_entity["attrib"].get("ftrackId") if not ftrack_id: - hierarchy = list(asset_data.get("parents") or []) - hierarchy.append(asset_doc["name"]) - path = "/".join(hierarchy) + path = folder_entity["path"] report[NOT_SYNCHRONIZED_TITLE].append(path) continue - asset_tasks = asset_data.get("tasks") or {} - asset_docs_task_names[ftrack_id] = ( - asset_doc, list(asset_tasks.keys()) - ) + folder_id = folder_entity["id"] + task_names = { + task_entity["name"] + for task_entity in task_entities_by_folder_id[folder_id] + } + folder_entity_task_names[ftrack_id] = (folder_entity, task_names) - task_entities = session.query(( + ft_task_entities = session.query(( "select id, name, parent_id, link from Task where project_id is {}" - ).format(project_entity["id"])).all() - task_entities_by_parent_id = collections.defaultdict(list) - for task_entity in task_entities: - parent_id = task_entity["parent_id"] - task_entities_by_parent_id[parent_id].append(task_entity) + ).format(ft_project_entity["id"])).all() + ft_task_entities_by_parent_id = collections.defaultdict(list) + for ft_task_entity in ft_task_entities: + parent_id = ft_task_entity["parent_id"] + ft_task_entities_by_parent_id[parent_id].append(ft_task_entity) output = [] - for ftrack_id, item in asset_docs_task_names.items(): - asset_doc, task_names = item - valid_task_entities = [] - for task_entity in task_entities_by_parent_id[ftrack_id]: - if task_entity["name"] in task_names: - valid_task_entities.append(task_entity) + for ftrack_id, item in folder_entity_task_names.items(): + folder_entity, task_names = item + valid_ft_task_entities = [] + for ft_task_entity in ft_task_entities_by_parent_id[ftrack_id]: + if ft_task_entity["name"] in task_names: + valid_ft_task_entities.append(ft_task_entity) else: - path = self._get_entity_path(task_entity) + path = self._get_entity_path(ft_task_entity) report[NOT_SYNCHRONIZED_TITLE].append(path) - if valid_task_entities: - output.append((asset_doc, valid_task_entities)) + if valid_ft_task_entities: + output.append((folder_entity, valid_ft_task_entities)) return output def _get_tasks_for_selection( - self, session, other_entities, task_entities, asset_docs, report + self, + session, + other_entities, + ft_task_entities, + folder_entities, + task_entities_by_folder_id, + report, ): all_tasks = object() - asset_docs_by_ftrack_id = {} - asset_docs_by_parent_id = collections.defaultdict(list) - for asset_doc in asset_docs: - asset_data = asset_doc["data"] - ftrack_id = asset_data.get("ftrackId") - parent_id = asset_data.get("visualParent") - asset_docs_by_parent_id[parent_id].append(asset_doc) + folder_entities_by_ftrack_id = {} + for folder_entity in folder_entities: + ftrack_id = folder_entity["attrib"].get("ftrackId") if ftrack_id: - asset_docs_by_ftrack_id[ftrack_id] = asset_doc + folder_entities_by_ftrack_id[ftrack_id] = folder_entity - missing_doc_ftrack_ids = {} + missing_entity_ftrack_ids = {} all_tasks_ids = set() task_names_by_ftrack_id = collections.defaultdict(list) for other_entity in other_entities: ftrack_id = other_entity["id"] - if ftrack_id not in asset_docs_by_ftrack_id: - missing_doc_ftrack_ids[ftrack_id] = None + if ftrack_id not in folder_entities_by_ftrack_id: + missing_entity_ftrack_ids[ftrack_id] = None continue all_tasks_ids.add(ftrack_id) task_names_by_ftrack_id[ftrack_id] = all_tasks - for task_entity in task_entities: - parent_id = task_entity["parent_id"] - if parent_id not in asset_docs_by_ftrack_id: - missing_doc_ftrack_ids[parent_id] = None + for ft_task_entity in ft_task_entities: + parent_id = ft_task_entity["parent_id"] + if parent_id not in folder_entities_by_ftrack_id: + missing_entity_ftrack_ids[parent_id] = None continue if all_tasks_ids not in all_tasks_ids: - task_names_by_ftrack_id[ftrack_id].append(task_entity["name"]) + task_names_by_ftrack_id[ftrack_id].append(ft_task_entity["name"]) ftrack_ids = set() - asset_doc_with_task_names_by_id = {} + folder_entity_with_task_names_by_id = {} for ftrack_id, task_names in task_names_by_ftrack_id.items(): - asset_doc = asset_docs_by_ftrack_id[ftrack_id] - asset_data = asset_doc["data"] - asset_tasks = asset_data.get("tasks") or {} + folder_entity = folder_entities_by_ftrack_id[ftrack_id] + folder_id = folder_entity["id"] + folder_task_names = { + task_entity["name"] + for task_entity in task_entities_by_folder_id[folder_id] + } if task_names is all_tasks: - task_names = list(asset_tasks.keys()) + task_names = list(folder_task_names) else: new_task_names = [] for task_name in task_names: - if task_name in asset_tasks: + if task_name in folder_task_names: new_task_names.append(task_name) continue - if ftrack_id not in missing_doc_ftrack_ids: - missing_doc_ftrack_ids[ftrack_id] = [] - if missing_doc_ftrack_ids[ftrack_id] is not None: - missing_doc_ftrack_ids[ftrack_id].append(task_name) + missing_entity_ftrack_ids.setdefault(ftrack_id, []) + if missing_entity_ftrack_ids[ftrack_id] is not None: + missing_entity_ftrack_ids[ftrack_id].append(task_name) task_names = new_task_names if task_names: ftrack_ids.add(ftrack_id) - asset_doc_with_task_names_by_id[ftrack_id] = ( - asset_doc, task_names + folder_entity_with_task_names_by_id[ftrack_id] = ( + folder_entity, task_names ) - task_entities = session.query(( + ft_task_entities = session.query(( "select id, name, parent_id from Task where parent_id in ({})" ).format(self.join_query_keys(ftrack_ids))).all() task_entitiy_by_parent_id = collections.defaultdict(list) - for task_entity in task_entities: - parent_id = task_entity["parent_id"] - task_entitiy_by_parent_id[parent_id].append(task_entity) + for ft_task_entity in ft_task_entities: + parent_id = ft_task_entity["parent_id"] + task_entitiy_by_parent_id[parent_id].append(ft_task_entity) output = [] - for ftrack_id, item in asset_doc_with_task_names_by_id.items(): + for ftrack_id, item in folder_entity_with_task_names_by_id.items(): asset_doc, task_names = item - valid_task_entities = [] - for task_entity in task_entitiy_by_parent_id[ftrack_id]: - if task_entity["name"] in task_names: - valid_task_entities.append(task_entity) + valid_ft_task_entities = [] + for ft_task_entity in task_entitiy_by_parent_id[ftrack_id]: + if ft_task_entity["name"] in task_names: + valid_ft_task_entities.append(ft_task_entity) else: - if ftrack_id not in missing_doc_ftrack_ids: - missing_doc_ftrack_ids[ftrack_id] = [] - if missing_doc_ftrack_ids[ftrack_id] is not None: - missing_doc_ftrack_ids[ftrack_id].append(task_name) - if valid_task_entities: - output.append((asset_doc, valid_task_entities)) + missing_entity_ftrack_ids.setdefault(ftrack_id, []) + if missing_entity_ftrack_ids[ftrack_id] is not None: + missing_entity_ftrack_ids[ftrack_id].append(task_name) + if valid_ft_task_entities: + output.append((asset_doc, valid_ft_task_entities)) # Store report information about not synchronized entities - if missing_doc_ftrack_ids: + if missing_entity_ftrack_ids: missing_entities = session.query( "select id, link from TypedContext where id in ({})".format( - self.join_query_keys(missing_doc_ftrack_ids.keys()) + self.join_query_keys(missing_entity_ftrack_ids.keys()) ) ).all() for missing_entity in missing_entities: path = self._get_entity_path(missing_entity) - task_names = missing_doc_ftrack_ids[missing_entity["id"]] + task_names = missing_entity_ftrack_ids[missing_entity["id"]] if task_names is None: report[NOT_SYNCHRONIZED_TITLE].append(path) else: @@ -495,7 +543,3 @@ def _get_tasks_for_selection( report[NOT_SYNCHRONIZED_TITLE].append(task_path) return output - - -def register(session): - FillWorkfileAttributeAction(session).register() diff --git a/client/ayon_ftrack/event_handlers_to_convert/action_prepare_project.py b/client/ayon_ftrack/event_handlers_to_convert/action_prepare_project.py deleted file mode 100644 index 22fae684..00000000 --- a/client/ayon_ftrack/event_handlers_to_convert/action_prepare_project.py +++ /dev/null @@ -1,450 +0,0 @@ -import json -import copy - -from openpype.client import get_project, create_project -from openpype.settings import ProjectSettings, SaveWarningExc - -from ayon_ftrack.common import ( - LocalAction, - get_ayon_attr_configs, - CUST_ATTR_AUTO_SYNC, -) -from ayon_ftrack.lib import get_ftrack_icon_url - - -class PrepareProjectLocal(LocalAction): - """Prepare project attributes in Anatomy.""" - - identifier = "prepare.project.local" - label = "Prepare Project" - description = "Set basic attributes on the project" - icon = get_ftrack_icon_url("PrepareProject.svg") - - role_list = ["Administrator", "Project Manager"] - - settings_key = "prepare_project" - - # Key to store info about trigerring create folder structure - create_project_structure_key = "create_folder_structure" - create_project_structure_identifier = "ayon.create.project.structure" - item_splitter = {"type": "label", "value": "---"} - _keys_order = ( - "fps", - "frameStart", - "frameEnd", - "handleStart", - "handleEnd", - "clipIn", - "clipOut", - "resolutionHeight", - "resolutionWidth", - "pixelAspect", - "applications", - "tools_env", - "library_project", - ) - - def discover(self, session, entities, event): - """Show only on project.""" - if ( - len(entities) != 1 - or entities[0].entity_type.lower() != "project" - ): - return False - - return self.valid_roles(session, entities, event) - - def interface(self, session, entities, event): - if event['data'].get('values', {}): - return - - # Inform user that this may take a while - self.show_message(event, "Preparing data... Please wait", True) - self.log.debug("Preparing data which will be shown") - - self.log.debug("Loading custom attributes") - - project_entity = entities[0] - project_name = project_entity["full_name"] - - project_settings = ProjectSettings(project_name) - - project_anatom_settings = project_settings["project_anatomy"] - root_items = self.prepare_root_items(project_anatom_settings) - - ca_items, multiselect_enumerators = ( - self.prepare_custom_attribute_items(project_anatom_settings) - ) - - self.log.debug("Heavy items are ready. Preparing last items group.") - - title = "Prepare Project" - items = [] - - # Add root items - items.extend(root_items) - - items.append(self.item_splitter) - items.append({ - "type": "label", - "value": "NOTE: Roots are crutial for path filling" - " (and creating folder structure).
" - ) - }) - root_items.append({ - "type": "label", - "value": ( - "WARNING: Do not change roots on running project," - " that will cause workflow issues.
" - ) - }) - - empty_text = "Enter root path here..." - - roots_entity = project_anatom_settings["roots"] - for root_name, root_entity in roots_entity.items(): - root_items.append(self.item_splitter) - root_items.append({ - "type": "label", - "value": "Root: \"{}\"".format(root_name) - }) - for platform_name, value_entity in root_entity.items(): - root_items.append({ - "label": platform_name, - "name": "__root__{}__{}".format(root_name, platform_name), - "type": "text", - "value": value_entity.value, - "empty_text": empty_text - }) - - root_items.append({ - "type": "hidden", - "name": "__rootnames__", - "value": json.dumps(list(roots_entity.keys())) - }) - - self.log.debug("Root items preparation ended.") - return root_items - - def _attributes_to_set(self, project_anatom_settings): - attributes_to_set = {} - - attribute_values_by_key = {} - for key, entity in project_anatom_settings["attributes"].items(): - attribute_values_by_key[key] = entity.value - - cust_attrs, hier_cust_attrs = get_ayon_attr_configs( - self.session, split_hierarchical=True - ) - - for attr in hier_cust_attrs: - key = attr["key"] - if key.startswith("avalon_"): - continue - attributes_to_set[key] = { - "label": attr["label"], - "object": attr, - "default": attribute_values_by_key.get(key) - } - - for attr in cust_attrs: - if attr["entity_type"].lower() != "show": - continue - key = attr["key"] - if key.startswith("avalon_"): - continue - attributes_to_set[key] = { - "label": attr["label"], - "object": attr, - "default": attribute_values_by_key.get(key) - } - - # Sort by label - attributes_to_set = dict(sorted( - attributes_to_set.items(), - key=lambda x: x[1]["label"] - )) - return attributes_to_set - - def prepare_custom_attribute_items(self, project_anatom_settings): - items = [] - multiselect_enumerators = [] - attributes_to_set = self._attributes_to_set(project_anatom_settings) - - self.log.debug("Preparing interface for keys: \"{}\"".format( - str([key for key in attributes_to_set]) - )) - - attribute_keys = set(attributes_to_set.keys()) - keys_order = [] - for key in self._keys_order: - if key in attribute_keys: - keys_order.append(key) - - attribute_keys = attribute_keys - set(keys_order) - for key in sorted(attribute_keys): - keys_order.append(key) - - for key in keys_order: - in_data = attributes_to_set[key] - attr = in_data["object"] - - # initial item definition - item = { - "name": key, - "label": in_data["label"] - } - - # cust attr type - may have different visualization - type_name = attr["type"]["name"].lower() - easy_types = ["text", "boolean", "date", "number"] - - easy_type = False - if type_name in easy_types: - easy_type = True - - elif type_name == "enumerator": - - attr_config = json.loads(attr["config"]) - attr_config_data = json.loads(attr_config["data"]) - - if attr_config["multiSelect"] is True: - multiselect_enumerators.append(self.item_splitter) - multiselect_enumerators.append({ - "type": "label", - "value": "NOTE: It is not allowed to use the same name" - " for multiple entities in the same project
" - ) - }) - - for name, ents in ft_ents_by_name.items(): - items.append({ - "type": "label", - "value": "## {}".format(name) - }) - paths = [] - for ent in ents: - ftrack_id = ent["id"] - ent_path = "/".join([_ent["name"] for _ent in ent["link"]]) - avalon_ent = self.avalon_ents_by_id.get(ftrack_id) - - if avalon_ent: - additional = " (synchronized)" - if avalon_ent["name"] != name: - additional = " (synchronized as {})".format( - avalon_ent["name"] - ) - ent_path += additional - paths.append(ent_path) - - items.append({ - "type": "label", - "value": '{}
'.format("NOTE: You can use Letters( a-Z )," - " Numbers( 0-9 ) and Underscore( _ )
" - ) - }) - - ft_project = self.cur_project - for ftrack_id in self.regex_failed: - ftrack_ent = self.ftrack_ents_by_id.get(ftrack_id) - if not ftrack_ent: - ftrack_ent = self.process_session.query( - self.entities_query_by_id.format( - ft_project["id"], ftrack_id - ) - ).one() - self.ftrack_ents_by_id[ftrack_id] = ftrack_ent - - name = ftrack_ent["name"] - ent_path_items = [_ent["name"] for _ent in ftrack_ent["link"][:-1]] - ent_path_items.append("{}".format(name)) - ent_path = "/".join(ent_path_items) - items.append({ - "type": "label", - "value": "{} - {}
".format(name, ent_path) - }) - - return items - - def report(self): - msg_len = len(self.duplicated) + len(self.regex_failed) - for msgs in self.report_items.values(): - msg_len += len(msgs) - - if msg_len == 0: - return - - items = [] - project_name = self.cur_project["full_name"] - title = "Synchronization report ({}):".format(project_name) - - keys = ["error", "warning", "info"] - for key in keys: - subitems = [] - if key == "warning": - subitems.extend(self.duplicated_report) - subitems.extend(self.regex_report) - - for _msg, _items in self.report_items[key].items(): - if not _items: - continue - - msg_items = _msg.split("||") - msg = msg_items[0] - subitems.append({ - "type": "label", - "value": "# {}".format(msg) - }) - - if len(msg_items) > 1: - for note in msg_items[1:]: - subitems.append({ - "type": "label", - "value": "NOTE: {}
".format(note) - }) - - if isinstance(_items, str): - _items = [_items] - subitems.append({ - "type": "label", - "value": '{}
'.format("NOTE: It is not allowed to use the same name" + # " for multiple entities in the same project
" + # ) + # }) + # + # for name, ents in ft_ents_by_name.items(): + # items.append({ + # "type": "label", + # "value": "## {}".format(name) + # }) + # paths = [] + # for ent in ents: + # ftrack_id = ent["id"] + # ent_path = "/".join([_ent["name"] for _ent in ent["link"]]) + # avalon_ent = self.avalon_ents_by_id.get(ftrack_id) + # + # if avalon_ent: + # additional = " (synchronized)" + # if avalon_ent["name"] != name: + # additional = " (synchronized as {})".format( + # avalon_ent["name"] + # ) + # ent_path += additional + # paths.append(ent_path) + # + # items.append({ + # "type": "label", + # "value": '{}
'.format("NOTE: You can use Letters( a-Z )," + # " Numbers( 0-9 ) and Underscore( _ )
" + # ) + # }) + # + # ft_project = self.cur_project + # for ftrack_id in self.regex_failed: + # ftrack_ent = self.ftrack_ents_by_id.get(ftrack_id) + # if not ftrack_ent: + # ftrack_ent = self.process_session.query( + # self.entities_query_by_id.format( + # ft_project["id"], ftrack_id + # ) + # ).one() + # self.ftrack_ents_by_id[ftrack_id] = ftrack_ent + # + # name = ftrack_ent["name"] + # ent_path_items = [_ent["name"] for _ent in ftrack_ent["link"][:-1]] + # ent_path_items.append("{}".format(name)) + # ent_path = "/".join(ent_path_items) + # items.append({ + # "type": "label", + # "value": "{} - {}
".format(name, ent_path) + # }) + # + # return items + # + # def report(self): + # msg_len = len(self.duplicated) + len(self.regex_failed) + # for msgs in self.report_items.values(): + # msg_len += len(msgs) + # + # if msg_len == 0: + # return + # + # items = [] + # project_name = self.cur_project["full_name"] + # title = "Synchronization report ({}):".format(project_name) + # + # keys = ["error", "warning", "info"] + # for key in keys: + # subitems = [] + # if key == "warning": + # subitems.extend(self.duplicated_report) + # subitems.extend(self.regex_report) + # + # for _msg, _items in self.report_items[key].items(): + # if not _items: + # continue + # + # msg_items = _msg.split("||") + # msg = msg_items[0] + # subitems.append({ + # "type": "label", + # "value": "# {}".format(msg) + # }) + # + # if len(msg_items) > 1: + # for note in msg_items[1:]: + # subitems.append({ + # "type": "label", + # "value": "NOTE: {}
".format(note) + # }) + # + # if isinstance(_items, str): + # _items = [_items] + # subitems.append({ + # "type": "label", + # "value": '{}
'.format("