-
-
-Details for Ubuntu
-Install git, cmake and curl - -```sh -sudo apt install build-essential checkinstall -sudo apt install git cmake curl -``` -#### Note: -In case you run in error about `xcb` when running OpenPype, -you'll need also additional libraries for Qt5: - -```sh -sudo apt install qt5-default -``` -or if you are on Ubuntu > 20.04, there is no `qt5-default` packages so you need to install its content individually: - -```sh -sudo apt-get install qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools -``` -
-
-
-Details for Centos
-Install git, cmake and curl - -```sh -sudo yum install qit cmake -``` - -#### Note: -In case you run in error about `xcb` when running OpenPype, -you'll need also additional libraries for Qt5: - -```sh -sudo yum install qt5-qtbase-devel -``` -
-
-
-#### To build OpenPype:
-
-1) Run `.\tools\create_env.sh` to create virtual environment in `.\venv`
-2) Run `.\tools\build.sh` to build OpenPype executables in `.\build\`
-
-
-Running OpenPype
-----------------
-
-OpenPype can by executed either from live sources (this repository) or from
-*"frozen code"* - executables that can be build using steps described above.
-
-If OpenPype is executed from live sources, it will use OpenPype version included in them. If
-it is executed from frozen code it will try to find latest OpenPype version installed locally
-on current computer and if it is not found, it will ask for its location. On that location
-OpenPype can be either in directories or zip files. OpenPype will try to find latest version and
-install it to user data directory (on Windows to `%LOCALAPPDATA%\pypeclub\openpype`, on Linux
-`~/.local/share/openpype` and on macOS in `~/Library/Application Support/openpype`).
-
-### From sources
-OpenPype can be run directly from sources by activating virtual environment:
-
-```sh
-poetry run python start.py tray
-```
-
-This will use current OpenPype version with sources. You can override this with `--use-version=x.x.x` and
-then OpenPype will try to find locally installed specified version (present in user data directory).
-
-### From frozen code
-
-You need to build OpenPype first. This will produce two executables - `openpype_gui(.exe)` and `openpype_console(.exe)`.
-First one will act as GUI application and will not create console (useful in production environments).
-The second one will create console and will write output there - useful for headless application and
-debugging purposes. If you need OpenPype version installed, just run `./tools/create_zip(.ps1|.sh)` without
-arguments and it will create zip file that OpenPype can use.
-
-
-Building documentation
-----------------------
-
-To build API documentation, run `.\tools\make_docs(.ps1|.sh)`. It will create html documentation
-from current sources in `.\docs\build`.
-
-**Note that it needs existing virtual environment.**
-
-Running tests
--------------
-
-To run tests, execute `.\tools\run_tests(.ps1|.sh)`.
-
-**Note that it needs existing virtual environment.**
-
-
-Developer tools
----------------
-
-In case you wish to add your own tools to `.\tools` folder without git tracking, it is possible by adding it with `dev_*` suffix (example: `dev_clear_pyc(.ps1|.sh)`).
-
-
-
-## Contributors โจ
-
-Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
-
-
-
-
-Use pyenv to install Python version for OpenPype build
- -You will need **bzip2**, **readline**, **sqlite3** and other libraries. - -For more details about Python build environments see: - -https://github.com/pyenv/pyenv/wiki#suggested-build-environment - -**For Ubuntu:** -```sh -sudo apt-get update; sudo apt-get install --no-install-recommends make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev libffi-dev liblzma-dev -``` - -**For Centos:** -```sh -yum install gcc zlib-devel bzip2 bzip2-devel readline-devel sqlite sqlite-devel openssl-devel tk-devel libffi-devel -``` - -**install pyenv** -```sh -curl https://pyenv.run | bash - -# you can add those to ~/.bashrc -export PATH="$HOME/.pyenv/bin:$PATH" -eval "$(pyenv init -)" -eval "$(pyenv virtualenv-init -)" - -# reload shell -exec $SHELL - -# install Python 3.9.x -pyenv install -v 3.9.6 - -# change path to OpenPype 3 -cd /path/to/openpype-3 - -# set local python version -pyenv local 3.9.6 - -``` -
-
+ payload(dict): - dictionary from json representation, expected to
+ come from _handle_return
+ """
+ if not payload:
+ return []
+
+ if isinstance(payload, str): # safety fallback
+ try:
+ payload = json.loads(payload)
+ except json.decoder.JSONDecodeError:
+ raise ValueError("Received broken JSON {}".format(payload))
+
+ if isinstance(payload, dict):
+ payload = [payload]
+
+ ret = []
+ # convert to AEItem to use dot donation
+ for d in payload:
+ if not d:
+ continue
+ # currently implemented and expected fields
+ item = AEItem(d.get('id'),
+ d.get('name'),
+ d.get('type'),
+ d.get('members'),
+ d.get('frameStart'),
+ d.get('framesDuration'),
+ d.get('frameRate'),
+ d.get('file_name'),
+ d.get("instance_id"),
+ d.get("width"),
+ d.get("height"),
+ d.get("is_placeholder"),
+ d.get("uuid"),
+ d.get("path"),
+ d.get("containing_comps"),)
+
+ ret.append(item)
+ return ret
+
+
+def get_stub():
+ """
+ Convenience function to get server RPC stub to call methods directed
+ for host (Photoshop).
+ It expects already created connection, started from client.
+ Currently created when panel is opened (PS: Window>Extensions>Avalon)
+ :return:
" + invalid_setting_str = "Found invalid settings:
{}".\ + format(break_str.join(invalid_settings)) + + formatting_data = { + "invalid_setting_str": invalid_setting_str, + "invalid_keys_str": invalid_keys_str + } + raise PublishXmlValidationError(self, msg, + formatting_data=formatting_data) + + if not os.path.exists(instance.data.get("source")): + scene_url = instance.data.get("source") + msg = "Scene file {} not found (saved under wrong name)".format( + scene_url + ) + formatting_data = { + "scene_url": scene_url + } + raise PublishXmlValidationError(self, msg, key="file_not_found", + formatting_data=formatting_data) diff --git a/openpype/hosts/aftereffects/resources/template.aep b/client/ayon_core/hosts/aftereffects/resources/template.aep similarity index 100% rename from openpype/hosts/aftereffects/resources/template.aep rename to client/ayon_core/hosts/aftereffects/resources/template.aep diff --git a/openpype/hosts/blender/__init__.py b/client/ayon_core/hosts/blender/__init__.py similarity index 100% rename from openpype/hosts/blender/__init__.py rename to client/ayon_core/hosts/blender/__init__.py diff --git a/client/ayon_core/hosts/blender/addon.py b/client/ayon_core/hosts/blender/addon.py new file mode 100644 index 0000000000..c3804382e5 --- /dev/null +++ b/client/ayon_core/hosts/blender/addon.py @@ -0,0 +1,72 @@ +import os +from ayon_core.modules import OpenPypeModule, IHostAddon + +BLENDER_ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) + + +class BlenderAddon(OpenPypeModule, IHostAddon): + name = "blender" + host_name = "blender" + + def initialize(self, module_settings): + self.enabled = True + + def add_implementation_envs(self, env, _app): + """Modify environments to contain all required for implementation.""" + # Prepare path to implementation script + implementation_user_script_path = os.path.join( + BLENDER_ROOT_DIR, + "blender_addon" + ) + + # Add blender implementation script path to PYTHONPATH + python_path = env.get("PYTHONPATH") or "" + python_path_parts = [ + path + for path in python_path.split(os.pathsep) + if path + ] + python_path_parts.insert(0, implementation_user_script_path) + env["PYTHONPATH"] = os.pathsep.join(python_path_parts) + + # Modify Blender user scripts path + previous_user_scripts = set() + # Implementation path is added to set for easier paths check inside + # loops - will be removed at the end + previous_user_scripts.add(implementation_user_script_path) + + ayon_blender_user_scripts = ( + env.get("AYON_BLENDER_USER_SCRIPTS") or "" + ) + for path in ayon_blender_user_scripts.split(os.pathsep): + if path: + previous_user_scripts.add(os.path.normpath(path)) + + blender_user_scripts = env.get("BLENDER_USER_SCRIPTS") or "" + for path in blender_user_scripts.split(os.pathsep): + if path: + previous_user_scripts.add(os.path.normpath(path)) + + # Remove implementation path from user script paths as is set to + # `BLENDER_USER_SCRIPTS` + previous_user_scripts.remove(implementation_user_script_path) + env["BLENDER_USER_SCRIPTS"] = implementation_user_script_path + + # Set custom user scripts env + env["AYON_BLENDER_USER_SCRIPTS"] = os.pathsep.join( + previous_user_scripts + ) + + # Define Qt binding if not defined + if not env.get("QT_PREFERRED_BINDING"): + env["QT_PREFERRED_BINDING"] = "PySide2" + + def get_launch_hook_paths(self, app): + if app.host_name != self.host_name: + return [] + return [ + os.path.join(BLENDER_ROOT_DIR, "hooks") + ] + + def get_workfile_extensions(self): + return [".blend"] diff --git a/openpype/hosts/blender/api/__init__.py b/client/ayon_core/hosts/blender/api/__init__.py similarity index 100% rename from openpype/hosts/blender/api/__init__.py rename to client/ayon_core/hosts/blender/api/__init__.py diff --git a/client/ayon_core/hosts/blender/api/action.py b/client/ayon_core/hosts/blender/api/action.py new file mode 100644 index 0000000000..865c2443e0 --- /dev/null +++ b/client/ayon_core/hosts/blender/api/action.py @@ -0,0 +1,47 @@ +import bpy + +import pyblish.api + +from ayon_core.pipeline.publish import get_errored_instances_from_context + + +class SelectInvalidAction(pyblish.api.Action): + """Select invalid objects in Blender when a publish plug-in failed.""" + label = "Select Invalid" + on = "failed" + icon = "search" + + def process(self, context, plugin): + errored_instances = get_errored_instances_from_context(context, + plugin=plugin) + + # Get the invalid nodes for the plug-ins + self.log.info("Finding invalid nodes...") + invalid = list() + for instance in errored_instances: + invalid_nodes = plugin.get_invalid(instance) + if invalid_nodes: + if isinstance(invalid_nodes, (list, tuple)): + invalid.extend(invalid_nodes) + else: + self.log.warning( + "Failed plug-in doesn't have any selectable objects." + ) + + bpy.ops.object.select_all(action='DESELECT') + + # Make sure every node is only processed once + invalid = list(set(invalid)) + if not invalid: + self.log.info("No invalid nodes found.") + return + + invalid_names = [obj.name for obj in invalid] + self.log.info( + "Selecting invalid objects: %s", ", ".join(invalid_names) + ) + # Select the objects and also make the last one the active object. + for obj in invalid: + obj.select_set(True) + + bpy.context.view_layer.objects.active = invalid[-1] diff --git a/openpype/hosts/blender/api/capture.py b/client/ayon_core/hosts/blender/api/capture.py similarity index 100% rename from openpype/hosts/blender/api/capture.py rename to client/ayon_core/hosts/blender/api/capture.py diff --git a/openpype/hosts/blender/api/colorspace.py b/client/ayon_core/hosts/blender/api/colorspace.py similarity index 100% rename from openpype/hosts/blender/api/colorspace.py rename to client/ayon_core/hosts/blender/api/colorspace.py diff --git a/openpype/hosts/blender/api/icons/pyblish-32x32.png b/client/ayon_core/hosts/blender/api/icons/pyblish-32x32.png similarity index 100% rename from openpype/hosts/blender/api/icons/pyblish-32x32.png rename to client/ayon_core/hosts/blender/api/icons/pyblish-32x32.png diff --git a/client/ayon_core/hosts/blender/api/lib.py b/client/ayon_core/hosts/blender/api/lib.py new file mode 100644 index 0000000000..458a275b51 --- /dev/null +++ b/client/ayon_core/hosts/blender/api/lib.py @@ -0,0 +1,367 @@ +import os +import traceback +import importlib +import contextlib +from typing import Dict, List, Union + +import bpy +import addon_utils +from ayon_core.lib import Logger + +from . import pipeline + +log = Logger.get_logger(__name__) + + +def load_scripts(paths): + """Copy of `load_scripts` from Blender's implementation. + + It is possible that this function will be changed in future and usage will + be based on Blender version. + """ + import bpy_types + + loaded_modules = set() + + previous_classes = [ + cls + for cls in bpy.types.bpy_struct.__subclasses__() + ] + + def register_module_call(mod): + register = getattr(mod, "register", None) + if register: + try: + register() + except: + traceback.print_exc() + else: + print("\nWarning! '%s' has no register function, " + "this is now a requirement for registerable scripts" % + mod.__file__) + + def unregister_module_call(mod): + unregister = getattr(mod, "unregister", None) + if unregister: + try: + unregister() + except: + traceback.print_exc() + + def test_reload(mod): + # reloading this causes internal errors + # because the classes from this module are stored internally + # possibly to refresh internal references too but for now, best not to. + if mod == bpy_types: + return mod + + try: + return importlib.reload(mod) + except: + traceback.print_exc() + + def test_register(mod): + if mod: + register_module_call(mod) + bpy.utils._global_loaded_modules.append(mod.__name__) + + from bpy_restrict_state import RestrictBlend + + with RestrictBlend(): + for base_path in paths: + for path_subdir in bpy.utils._script_module_dirs: + path = os.path.join(base_path, path_subdir) + if not os.path.isdir(path): + continue + + bpy.utils._sys_path_ensure_prepend(path) + + # Only add to 'sys.modules' unless this is 'startup'. + if path_subdir != "startup": + continue + for mod in bpy.utils.modules_from_path(path, loaded_modules): + test_register(mod) + + addons_paths = [] + for base_path in paths: + addons_path = os.path.join(base_path, "addons") + if not os.path.exists(addons_path): + continue + addons_paths.append(addons_path) + addons_module_path = os.path.join(addons_path, "modules") + if os.path.exists(addons_module_path): + bpy.utils._sys_path_ensure_prepend(addons_module_path) + + if addons_paths: + # Fake addons + origin_paths = addon_utils.paths + + def new_paths(): + paths = origin_paths() + addons_paths + return paths + + addon_utils.paths = new_paths + addon_utils.modules_refresh() + + # load template (if set) + if any(bpy.utils.app_template_paths()): + import bl_app_template_utils + bl_app_template_utils.reset(reload_scripts=False) + del bl_app_template_utils + + for cls in bpy.types.bpy_struct.__subclasses__(): + if cls in previous_classes: + continue + if not getattr(cls, "is_registered", False): + continue + for subcls in cls.__subclasses__(): + if not subcls.is_registered: + print( + "Warning, unregistered class: %s(%s)" % + (subcls.__name__, cls.__name__) + ) + + +def append_user_scripts(): + user_scripts = os.environ.get("AYON_BLENDER_USER_SCRIPTS") + if not user_scripts: + return + + try: + load_scripts(user_scripts.split(os.pathsep)) + except Exception: + print("Couldn't load user scripts \"{}\"".format(user_scripts)) + traceback.print_exc() + + +def set_app_templates_path(): + # Blender requires the app templates to be in `BLENDER_USER_SCRIPTS`. + # After running Blender, we set that variable to our custom path, so + # that the user can use their custom app templates. + + # We look among the scripts paths for one of the paths that contains + # the app templates. The path must contain the subfolder + # `startup/bl_app_templates_user`. + paths = os.environ.get("AYON_BLENDER_USER_SCRIPTS").split(os.pathsep) + + app_templates_path = None + for path in paths: + if os.path.isdir( + os.path.join(path, "startup", "bl_app_templates_user")): + app_templates_path = path + break + + if app_templates_path and os.path.isdir(app_templates_path): + os.environ["BLENDER_USER_SCRIPTS"] = app_templates_path + + +def imprint(node: bpy.types.bpy_struct_meta_idprop, data: Dict): + r"""Write `data` to `node` as userDefined attributes + + Arguments: + node: Long name of node + data: Dictionary of key/value pairs + + Example: + >>> import bpy + >>> def compute(): + ... return 6 + ... + >>> bpy.ops.mesh.primitive_cube_add() + >>> cube = bpy.context.view_layer.objects.active + >>> imprint(cube, { + ... "regularString": "myFamily", + ... "computedValue": lambda: compute() + ... }) + ... + >>> cube['avalon']['computedValue'] + 6 + """ + + imprint_data = dict() + + for key, value in data.items(): + if value is None: + continue + + if callable(value): + # Support values evaluated at imprint + value = value() + + if not isinstance(value, (int, float, bool, str, list, dict)): + raise TypeError(f"Unsupported type: {type(value)}") + + imprint_data[key] = value + + pipeline.metadata_update(node, imprint_data) + + +def lsattr(attr: str, + value: Union[str, int, bool, List, Dict, None] = None) -> List: + r"""Return nodes matching `attr` and `value` + + Arguments: + attr: Name of Blender property + value: Value of attribute. If none + is provided, return all nodes with this attribute. + + Example: + >>> lsattr("id", "myId") + ... [bpy.data.objects["myNode"] + >>> lsattr("id") + ... [bpy.data.objects["myNode"], bpy.data.objects["myOtherNode"]] + + Returns: + list + """ + + return lsattrs({attr: value}) + + +def lsattrs(attrs: Dict) -> List: + r"""Return nodes with the given attribute(s). + + Arguments: + attrs: Name and value pairs of expected matches + + Example: + >>> lsattrs({"age": 5}) # Return nodes with an `age` of 5 + # Return nodes with both `age` and `color` of 5 and blue + >>> lsattrs({"age": 5, "color": "blue"}) + + Returns a list. + + """ + + # For now return all objects, not filtered by scene/collection/view_layer. + matches = set() + for coll in dir(bpy.data): + if not isinstance( + getattr(bpy.data, coll), + bpy.types.bpy_prop_collection, + ): + continue + for node in getattr(bpy.data, coll): + for attr, value in attrs.items(): + avalon_prop = node.get(pipeline.AVALON_PROPERTY) + if not avalon_prop: + continue + if (avalon_prop.get(attr) + and (value is None or avalon_prop.get(attr) == value)): + matches.add(node) + return list(matches) + + +def read(node: bpy.types.bpy_struct_meta_idprop): + """Return user-defined attributes from `node`""" + + data = dict(node.get(pipeline.AVALON_PROPERTY, {})) + + # Ignore hidden/internal data + data = { + key: value + for key, value in data.items() if not key.startswith("_") + } + + return data + + +def get_selected_collections(): + """ + Returns a list of the currently selected collections in the outliner. + + Raises: + RuntimeError: If the outliner cannot be found in the main Blender + window. + + Returns: + list: A list of `bpy.types.Collection` objects that are currently + selected in the outliner. + """ + window = bpy.context.window or bpy.context.window_manager.windows[0] + + try: + area = next( + area for area in window.screen.areas + if area.type == 'OUTLINER') + region = next( + region for region in area.regions + if region.type == 'WINDOW') + except StopIteration as e: + raise RuntimeError("Could not find outliner. An outliner space " + "must be in the main Blender window.") from e + + with bpy.context.temp_override( + window=window, + area=area, + region=region, + screen=window.screen + ): + ids = bpy.context.selected_ids + + return [id for id in ids if isinstance(id, bpy.types.Collection)] + + +def get_selection(include_collections: bool = False) -> List[bpy.types.Object]: + """ + Returns a list of selected objects in the current Blender scene. + + Args: + include_collections (bool, optional): Whether to include selected + collections in the result. Defaults to False. + + Returns: + List[bpy.types.Object]: A list of selected objects. + """ + selection = [obj for obj in bpy.context.scene.objects if obj.select_get()] + + if include_collections: + selection.extend(get_selected_collections()) + + return selection + + +@contextlib.contextmanager +def maintained_selection(): + r"""Maintain selection during context + + Example: + >>> with maintained_selection(): + ... # Modify selection + ... bpy.ops.object.select_all(action='DESELECT') + >>> # Selection restored + """ + + previous_selection = get_selection() + previous_active = bpy.context.view_layer.objects.active + try: + yield + finally: + # Clear the selection + for node in get_selection(): + node.select_set(state=False) + if previous_selection: + for node in previous_selection: + try: + node.select_set(state=True) + except ReferenceError: + # This could happen if a selected node was deleted during + # the context. + log.exception("Failed to reselect") + continue + try: + bpy.context.view_layer.objects.active = previous_active + except ReferenceError: + # This could happen if the active node was deleted during the + # context. + log.exception("Failed to set active object.") + + +@contextlib.contextmanager +def maintained_time(): + """Maintain current frame during context.""" + current_time = bpy.context.scene.frame_current + try: + yield + finally: + bpy.context.scene.frame_current = current_time diff --git a/openpype/hosts/blender/api/ops.py b/client/ayon_core/hosts/blender/api/ops.py similarity index 91% rename from openpype/hosts/blender/api/ops.py rename to client/ayon_core/hosts/blender/api/ops.py index f4d96e563a..dcbc44bcad 100644 --- a/openpype/hosts/blender/api/ops.py +++ b/client/ayon_core/hosts/blender/api/ops.py @@ -15,10 +15,9 @@ import bpy import bpy.utils.previews -from openpype import style -from openpype import AYON_SERVER_ENABLED -from openpype.pipeline import get_current_asset_name, get_current_task_name -from openpype.tools.utils import host_tools +from ayon_core import style +from ayon_core.pipeline import get_current_asset_name, get_current_task_name +from ayon_core.tools.utils import host_tools from .workio import OpenFileCacher from . import pipeline @@ -312,14 +311,6 @@ class LaunchLoader(LaunchQtApp): bl_label = "Load..." _tool_name = "loader" - def before_window_show(self): - if AYON_SERVER_ENABLED: - return - self._window.set_context( - {"asset": get_current_asset_name()}, - refresh=True - ) - class LaunchPublisher(LaunchQtApp): """Launch Avalon Publisher.""" @@ -339,11 +330,6 @@ class LaunchManager(LaunchQtApp): bl_label = "Manage..." _tool_name = "sceneinventory" - def before_window_show(self): - if AYON_SERVER_ENABLED: - return - self._window.refresh() - class LaunchLibrary(LaunchQtApp): """Launch Library Loader.""" @@ -352,11 +338,6 @@ class LaunchLibrary(LaunchQtApp): bl_label = "Library..." _tool_name = "libraryloader" - def before_window_show(self): - if AYON_SERVER_ENABLED: - return - self._window.refresh() - class LaunchWorkFiles(LaunchQtApp): """Launch Avalon Work Files.""" @@ -366,22 +347,7 @@ class LaunchWorkFiles(LaunchQtApp): _tool_name = "workfiles" def execute(self, context): - result = super().execute(context) - if not AYON_SERVER_ENABLED: - self._window.set_context({ - "asset": get_current_asset_name(), - "task": get_current_task_name() - }) - return result - - def before_window_show(self): - if AYON_SERVER_ENABLED: - return - self._window.root = str(Path( - os.environ.get("AVALON_WORKDIR", ""), - os.environ.get("AVALON_SCENEDIR", ""), - )) - self._window.refresh() + return super().execute(context) class SetFrameRange(bpy.types.Operator): @@ -408,7 +374,7 @@ class TOPBAR_MT_avalon(bpy.types.Menu): """Avalon menu.""" bl_idname = "TOPBAR_MT_avalon" - bl_label = os.environ.get("AVALON_LABEL") + bl_label = os.environ.get("AYON_MENU_LABEL") def draw(self, context): """Draw the menu in the UI.""" diff --git a/client/ayon_core/hosts/blender/api/pipeline.py b/client/ayon_core/hosts/blender/api/pipeline.py new file mode 100644 index 0000000000..6801b1f71b --- /dev/null +++ b/client/ayon_core/hosts/blender/api/pipeline.py @@ -0,0 +1,574 @@ +import os +import sys +import traceback +from typing import Callable, Dict, Iterator, List, Optional + +import bpy + +from . import lib +from . import ops + +import pyblish.api + +from ayon_core.host import ( + HostBase, + IWorkfileHost, + IPublishHost, + ILoadHost +) +from ayon_core.client import get_asset_by_name +from ayon_core.pipeline import ( + schema, + legacy_io, + get_current_project_name, + get_current_asset_name, + register_loader_plugin_path, + register_creator_plugin_path, + deregister_loader_plugin_path, + deregister_creator_plugin_path, + AVALON_CONTAINER_ID, +) +from ayon_core.lib import ( + Logger, + register_event_callback, + emit_event +) +import ayon_core.hosts.blender +from ayon_core.settings import get_project_settings +from .workio import ( + open_file, + save_file, + current_file, + has_unsaved_changes, + file_extensions, + work_root, +) + + +HOST_DIR = os.path.dirname(os.path.abspath(ayon_core.hosts.blender.__file__)) +PLUGINS_DIR = os.path.join(HOST_DIR, "plugins") +PUBLISH_PATH = os.path.join(PLUGINS_DIR, "publish") +LOAD_PATH = os.path.join(PLUGINS_DIR, "load") +CREATE_PATH = os.path.join(PLUGINS_DIR, "create") + +ORIGINAL_EXCEPTHOOK = sys.excepthook + +AVALON_INSTANCES = "AVALON_INSTANCES" +AVALON_CONTAINERS = "AVALON_CONTAINERS" +AVALON_PROPERTY = 'avalon' +IS_HEADLESS = bpy.app.background + +log = Logger.get_logger(__name__) + + +class BlenderHost(HostBase, IWorkfileHost, IPublishHost, ILoadHost): + name = "blender" + + def install(self): + """Override install method from HostBase. + Install Blender host functionality.""" + install() + + def get_containers(self) -> Iterator: + """List containers from active Blender scene.""" + return ls() + + def get_workfile_extensions(self) -> List[str]: + """Override get_workfile_extensions method from IWorkfileHost. + Get workfile possible extensions. + + Returns: + List[str]: Workfile extensions. + """ + return file_extensions() + + def save_workfile(self, dst_path: str = None): + """Override save_workfile method from IWorkfileHost. + Save currently opened workfile. + + Args: + dst_path (str): Where the current scene should be saved. Or use + current path if `None` is passed. + """ + save_file(dst_path if dst_path else bpy.data.filepath) + + def open_workfile(self, filepath: str): + """Override open_workfile method from IWorkfileHost. + Open workfile at specified filepath in the host. + + Args: + filepath (str): Path to workfile. + """ + open_file(filepath) + + def get_current_workfile(self) -> str: + """Override get_current_workfile method from IWorkfileHost. + Retrieve currently opened workfile path. + + Returns: + str: Path to currently opened workfile. + """ + return current_file() + + def workfile_has_unsaved_changes(self) -> bool: + """Override wokfile_has_unsaved_changes method from IWorkfileHost. + Returns True if opened workfile has no unsaved changes. + + Returns: + bool: True if scene is saved and False if it has unsaved + modifications. + """ + return has_unsaved_changes() + + def work_root(self, session) -> str: + """Override work_root method from IWorkfileHost. + Modify workdir per host. + + Args: + session (dict): Session context data. + + Returns: + str: Path to new workdir. + """ + return work_root(session) + + def get_context_data(self) -> dict: + """Override abstract method from IPublishHost. + Get global data related to creation-publishing from workfile. + + Returns: + dict: Context data stored using 'update_context_data'. + """ + property = bpy.context.scene.get(AVALON_PROPERTY) + if property: + return property.to_dict() + return {} + + def update_context_data(self, data: dict, changes: dict): + """Override abstract method from IPublishHost. + Store global context data to workfile. + + Args: + data (dict): New data as are. + changes (dict): Only data that has been changed. Each value has + tuple with '(