poly-hammer-utils 0.0.1__tar.gz

poly_hammer_utils-0.0.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: poly-hammer-utils
+Version: 0.0.1
+Summary: 
+Author: Poly Hammer
+Author-email: info@polyhammer.com
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: requirements-parser (>=0.11.0,<0.12.0)
+Description-Content-Type: text/markdown
+
+# Poly Hammer Utils
+
+[![Publish](https://github.com/poly-hammer/poly-hammer-utils/actions/workflows/publish.yaml/badge.svg)](https://github.com/poly-hammer/poly-hammer-utils/actions/workflows/publish.yaml)
+
+
+A general purpose package that holds our dev utilities.

poly_hammer_utils-0.0.1/README.md

@@ -0,0 +1,6 @@
+# Poly Hammer Utils
+
+[![Publish](https://github.com/poly-hammer/poly-hammer-utils/actions/workflows/publish.yaml/badge.svg)](https://github.com/poly-hammer/poly-hammer-utils/actions/workflows/publish.yaml)
+
+
+A general purpose package that holds our dev utilities.

poly_hammer_utils-0.0.1/pyproject.toml

@@ -0,0 +1,16 @@
+[tool.poetry]
+name = "poly-hammer-utils"
+version = "0.0.1"
+description = ""
+authors = ["Poly Hammer <info@polyhammer.com>"]
+readme = "README.md"
+packages = [{include = "poly_hammer_utils", from = "src"}]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+requirements-parser = "^0.11.0"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

poly_hammer_utils-0.0.1/src/poly_hammer_utils/addon/packager.py

@@ -0,0 +1,229 @@
+import os
+import ast
+import sys
+import shutil
+import logging
+import subprocess
+import requirements
+from pathlib import Path
+
+try:
+    import bpy
+    import addon_utils
+except ImportError:
+    pass
+
+REPO_ROOT = Path(__file__).parent.parent.parent.parent.parent
+
+
+IGNORE_PATTERNS = [
+    "__pycache__",
+    "*.pyc"
+]
+
+
+class AddonPackager:
+
+    def __init__(self, addon_name, addon_folder_path, output_folder):
+        """
+        Initializes the class and sets the addon module name.
+        """
+        self.addon_name = addon_name
+        self.addon_folder_path = addon_folder_path
+        self.output_folder = output_folder
+
+    @staticmethod
+    def get_dict_from_python_file(python_file, dict_name):
+        """
+        Gets the first dictionary from the given file that matches the given variable name.
+
+        :param object python_file: A file object to read from.
+        :param str dict_name: The variable name of a dictionary.
+        :return dict: The value of the dictionary.
+        """
+        dictionary = {}
+        tree = ast.parse(python_file.read())
+
+        for item in tree.body:
+            if hasattr(item, 'targets'):
+                for target in item.targets:
+                    if getattr(target, 'id', None) == dict_name:
+                        for index, key in enumerate(item.value.keys):
+                            # add string as dictionary value
+                            if hasattr(item.value.values[index], 's'):
+                                dictionary[key.s] = item.value.values[index].s
+
+                            # add number as dictionary value
+                            elif hasattr(item.value.values[index], 'n'):
+                                dictionary[key.s] = item.value.values[index].n
+
+                            # add list as dictionary value
+                            elif hasattr(item.value.values[index], 'elts'):
+                                list_value = []
+                                for element in item.value.values[index].elts:
+                                    # add a number to the list
+                                    if hasattr(element, 'n'):
+                                        list_value.append(element.n)
+
+                                    # add a string to the list
+                                    elif hasattr(element, 's'):
+                                        list_value.append(element.s)
+
+                                dictionary[key.s] = list_value
+                        break
+        return dictionary
+
+    def get_addon_version_number(self, addon_folder_path):
+        """
+        Gets the version number from the addons bl_info
+
+        :param str addon_folder_path: The path to the addon folder.
+        :return str: The version of the addon.
+        """
+        addon_init = open(os.path.join(addon_folder_path, '__init__.py'))
+
+        bl_info = self.get_dict_from_python_file(addon_init, 'bl_info')
+        version_numbers = [str(number) for number in bl_info['version']]
+        version_number = '.'.join(version_numbers)
+        return version_number
+
+    def get_addon_zip_path(self):
+        """
+        Gets the path to the addons zip file.
+
+        :return str: The full path to the released zip file.
+        """
+        # get the versioned addon paths
+        version_number = self.get_addon_version_number(self.addon_folder_path)
+        addon_zip_file = f'{self.addon_name}_{version_number}.zip'
+        output_folder_path = os.path.join(self.output_folder, addon_zip_file)
+        if not os.path.exists(os.path.dirname(output_folder_path)):
+            os.makedirs(os.path.dirname(output_folder_path))
+
+        return output_folder_path
+
+    @staticmethod
+    def set_folder_contents_permissions(folder_path, permission_level):
+        """
+        Goes through all files and folders contained in the folder and modifies their permissions to
+        the given permissions.
+
+        :param str folder_path: The full path to the folder you would like to modify permissions on.
+        :param octal permission_level: The octal permissions value.
+        """
+        for root, directories, files in os.walk(folder_path):
+            for directory in directories:
+                os.chmod(os.path.join(root, directory), permission_level)
+            for file in files:
+                os.chmod(os.path.join(root, file), permission_level)
+
+    def copy_addon(self):
+        """
+        Copy the addon.
+        """
+        destination = os.path.join(self.output_folder, self.addon_name)
+
+        logging.debug(f'Copying addon "{self.addon_folder_path}" to "{destination}"')
+
+        # change the permissions to allow the folders contents to be modified.
+        if sys.platform == 'win32':
+            self.set_folder_contents_permissions(os.path.join(self.addon_folder_path, os.pardir), 0o777)
+
+        shutil.rmtree(destination, ignore_errors=True)
+        shutil.copytree(self.addon_folder_path, destination, ignore=shutil.ignore_patterns('*pyc'))
+
+        # change the permissions to allow the folders contents to be modified.
+        if sys.platform == 'win32':
+            self.set_folder_contents_permissions(os.path.join(self.output_folder, os.pardir), 0o777)
+
+    def zip_addon(self):
+        """
+        Zips up the addon.
+        """
+        logging.debug(f'zipping addon "{self.addon_name}" to "{self.output_folder}"')
+        # get the folder paths
+        versioned_zip_file_path = self.get_addon_zip_path()
+        versioned_folder_path = versioned_zip_file_path.replace('.zip', '')
+
+        # change the permissions to allow the folders contents to be modified.
+        if sys.platform == 'win32':
+            self.set_folder_contents_permissions(os.path.join(self.addon_folder_path, os.pardir), 0o777)
+
+        # remove the existing zip archive
+        if os.path.exists(versioned_zip_file_path):
+            try:
+                os.remove(versioned_zip_file_path)
+            except PermissionError:
+                logging.warning(f'Could not delete {versioned_folder_path}!')
+
+        # copy the addon module in to the versioned directory with its addon module name as a sub directory
+        shutil.copytree(
+            self.addon_folder_path,
+            os.path.join(versioned_folder_path, self.addon_name),
+            ignore=shutil.ignore_patterns(*IGNORE_PATTERNS)
+        )
+
+        # make a zip archive of the copied folder
+        shutil.make_archive(versioned_folder_path, 'zip', versioned_folder_path)
+
+        # remove the copied directory
+        shutil.rmtree(versioned_folder_path)
+
+        # return the full path to the zip file
+        return versioned_zip_file_path
+
+    def install_addon(self):
+        """
+        Installs the given addons from the release folder.
+        """
+        zip_file_path = self.get_addon_zip_path()
+
+        # install addon if it isn't installed
+        if not self.is_addon_installed(self.addon_name):
+            bpy.ops.preferences.addon_install(filepath=zip_file_path)
+
+        # enable addon if it is disabled
+        if self.addon_name not in bpy.context.preferences.addons.keys():
+            bpy.ops.preferences.addon_enable(module=self.addon_name)
+
+    @staticmethod
+    def is_addon_installed(module_name):
+        """
+        Checks if the given addon module is currently installed.
+
+        :param str module_name: The addon module name.
+        :return bool: True or False depending on whether the addon exists.
+        """
+        return module_name in [module.bl_info.get('name') for module in addon_utils.modules()]
+    
+
+def install_package(package):
+    subprocess.check_call([
+        sys.executable,
+        "-m",
+        "pip",
+        "install",
+        "--upgrade",
+        "--target=./src/addons/metahuman/resources/packages",
+        package
+    ],
+        cwd=REPO_ROOT
+    )
+
+
+def install_requirements():
+    requirements_file_path = os.path.join(os.path.dirname(__file__), 'requirements.txt')
+    with open(requirements_file_path, 'r') as requirements_file:
+        for requirement in requirements.parse(requirements_file):
+            versioned_package = f'{requirement.name}{"".join(requirement.specs[0])}'
+            install_package(versioned_package)
+
+if __name__ == "__main__":
+    addon_packager = AddonPackager(
+        addon_name='metahuman',
+        addon_folder_path=str(REPO_ROOT / 'src' / 'addons' / 'metahuman'),
+        output_folder=str(REPO_ROOT / 'release')
+    )
+
+    addon_packager.zip_addon()
+

poly_hammer_utils-0.0.1/src/poly_hammer_utils/constants.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+
+RESOURCES_FOLDER = Path(__file__).parent / 'resources'
+
+BLENDER_STARTUP_SCRIPT = RESOURCES_FOLDER / 'scripts' / 'blender' / 'startup.py'

poly_hammer_utils-0.0.1/src/poly_hammer_utils/helpers.py

@@ -0,0 +1,66 @@
+import os
+import bpy
+import sys
+import importlib
+from types import ModuleType
+repo_folder = os.path.join(os.path.dirname(__file__), os.pardir)
+# from addon_packager import AddonPackager
+
+
+def deep_reload(m: ModuleType):
+    name = m.__name__  # get the name that is used in sys.modules
+    name_ext = name + '.'  # support finding sub modules or packages
+
+    def compare(loaded: str):
+        return (loaded == name) or loaded.startswith(name_ext)
+
+    all_mods = tuple(sys.modules)  # prevent changing iterable while iterating over it
+    sub_mods = filter(compare, all_mods)
+    for pkg in sorted(sub_mods, key=lambda item: item.count('.'), reverse=True):
+        importlib.reload(sys.modules[pkg])  # reload packages, beginning with the most deeply nested
+
+
+def reload_addon_source_code(addons, only_unregister=False):
+    """"
+    Does a full reload of the addons directly from their source code in the repo. This
+    tends to be the preferred method of working since stack traces will link back to the
+    source code.
+
+    :param list addons: A list of addon names.
+    :param bool only_unregister: Whether or not to only unregister the addon code.
+    """
+    # forces reloading of modules, regeneration of properties, and sends all errors
+    # to stderr instead of a dialog
+    for addon in addons:
+        os.environ[f'{addon.upper()}_DEV'] = '1'
+        addon = importlib.import_module(addon)
+
+        addon.unregister()
+        deep_reload(addon)
+        # importlib.reload(addon)
+
+        if not only_unregister:
+            addon.register()
+
+
+def reload_addon_zips(addons):
+    """
+    Does a full install and reload of the addons from their zip files. This is useful when
+    testing the full addon installation, and when you need to see the addon preferences UI which
+    is only available when a addon is physically installed.
+
+    :param list addons: A list of addon names.
+    """
+    # unregister any registered addons
+    reload_addon_source_code(addons, only_unregister=True)
+
+    # zip up each addon
+    for addon in addons:
+        os.environ[f'{addon.upper()}_DEV'] = '1'
+        addon_folder_path = os.path.join(repo_folder, addon)
+        release_folder_path = os.path.join(repo_folder, 'release')
+        addon_packager = AddonPackager(addon, addon_folder_path, release_folder_path)
+        addon_packager.zip_addon()
+        addon_packager.install_addon()
+
+    bpy.ops.script.reload()

poly_hammer_utils-0.0.1/src/poly_hammer_utils/launch.py

@@ -0,0 +1,21 @@
+import sys
+from .utilities import launch_blender, launch_unreal
+app_name = sys.argv[1]
+app_version = sys.argv[2]
+debug_on = sys.argv[3]
+
+
+if __name__ == '__main__':
+    debug_on = '1' if debug_on.lower() == 'yes' else '0'
+
+    if app_name == 'blender':
+        launch_blender(
+            version=app_version,
+            debug=debug_on
+        )
+
+    if app_name == 'unreal':
+        launch_unreal(
+            version=app_version,
+            debug=debug_on
+        )

poly_hammer_utils-0.0.1/src/poly_hammer_utils/resources/addon-requirements/requirements.txt

@@ -0,0 +1 @@
+sentry-sdk==1.38.0

poly_hammer_utils-0.0.1/src/poly_hammer_utils/resources/scripts/blender/startup.py

@@ -0,0 +1,45 @@
+import os
+import sys
+import bpy
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+logging.basicConfig(level=logging.DEBUG)
+
+if int(os.environ.get('BLENDER_DEBUGGING_ON', '0')):
+    try:
+        import debugpy
+        port = int(os.environ.get('BLENDER_DEBUG_PORT', 5678))
+        debugpy.configure(python=sys.executable)
+        debugpy.listen(port)
+        logger.info(f'Waiting for debugger to attach on port {port}...')
+        debugpy.wait_for_client()
+    except ImportError:
+        logger.error(
+            'Failed to initialize debugger because debugpy is not available '
+            'in the current python environment.'
+        )
+
+BLENDER_SCRIPTS_FOLDERS = [Path(i) for i in os.environ.get('BLENDER_SCRIPTS_FOLDERS', '').split(os.pathsep)]
+
+for scripts_folder in BLENDER_SCRIPTS_FOLDERS:
+    script_directory = bpy.context.preferences.filepaths.script_directories.get(scripts_folder.parent.name)
+    if script_directory:
+        bpy.context.preferences.filepaths.script_directories.remove(script_directory)
+
+    script_directory = bpy.context.preferences.filepaths.script_directories.new()
+    script_directory.name = scripts_folder.parent.name
+    script_directory.directory = str(scripts_folder)
+
+
+try:
+    bpy.ops.script.reload()
+except ValueError:
+    pass
+
+for scripts_folder in BLENDER_SCRIPTS_FOLDERS:
+    for addon in os.listdir(scripts_folder / 'addons'):
+        if (scripts_folder / 'addons' / addon).is_dir():
+            bpy.ops.preferences.addon_enable(module=addon)

poly_hammer_utils-0.0.1/src/poly_hammer_utils/resources/scripts/unreal/init_unreal.py

@@ -0,0 +1,22 @@
+import os
+import sys
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+logging.basicConfig(level=logging.DEBUG)
+
+
+if int(os.environ.get('UNREAL_DEBUGGING_ON', '0')):
+    import debugpy
+    platform_folder = 'Linux'
+    if sys.platform == 'win32':
+        platform_folder = 'Win64'
+
+    port = int(os.environ.get('UNREAL_DEBUG_PORT', 5678))
+    python_exe_path = Path(sys.executable).parent.parent / 'ThirdParty' / 'Python3' / platform_folder / 'python'
+    debugpy.configure(python=os.environ.get('UNREAL_PYTHON_EXE', str(python_exe_path)))
+    debugpy.listen(port)
+    logger.info(f'Waiting for debugger to attach on port {port}...')
+    debugpy.wait_for_client()

poly_hammer_utils-0.0.1/src/poly_hammer_utils/utilities.py

@@ -0,0 +1,109 @@
+import os
+import sys
+import site
+import subprocess
+import poly_hammer_utils
+from pathlib import Path
+from poly_hammer_utils.constants import BLENDER_STARTUP_SCRIPT
+
+
+REPO_ROOT = Path(__file__).parent.parent.parent.parent
+UNREAL_PROJECT  =  Path(os.environ['UNREAL_PROJECT'])
+UNREAL_EXE  =  os.environ.get('UNREAL_EXE')
+UNREAL_STARTUP_SCRIPT = Path(__file__).parent / 'resources' / 'scripts' / 'unreal' / 'init_unreal.py'
+
+
+def shell(command: str, **kwargs):
+    """
+    Runs the command is a fully qualified shell.
+
+    Args:
+        command (str): A command.
+
+    Raises:
+        OSError: The error cause by the shell.
+    """
+    process = subprocess.Popen(
+        command,
+        shell=True,
+        universal_newlines=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        **kwargs
+    )
+
+    output = []
+    for line in iter(process.stdout.readline, ""): # type: ignore
+        output += [line.rstrip()]
+        sys.stdout.write(line)
+
+    process.wait()
+
+    if process.returncode != 0:
+        raise OSError("\n".join(output))
+        
+
+def launch_blender(version: str, debug: str):
+    if sys.platform == 'win32':
+        exe_path = rf"C:\Program Files\Blender Foundation\Blender {version}\blender.exe"
+    else:
+        exe_path = None
+
+    if exe_path:
+        command = f'"{exe_path}" --python-use-system-env --python "{BLENDER_STARTUP_SCRIPT}"'
+        shell(
+            command, 
+            env={
+                **os.environ.copy(), 
+                'PYTHONUNBUFFERED': '1',
+                'BLENDER_APP_VERSION': version,
+                'BLENDER_DEBUGGING_ON': debug,
+                'PYTHONPATH': ';'.join(
+                    site.getsitepackages() + [str(Path(poly_hammer_utils.__file__).parent.parent)]
+                )
+            }
+        )
+
+
+def launch_unreal(version: str, debug: str):
+    if sys.platform == 'win32':
+        exe_path = rf'C:\Program Files\Epic Games\UE_{version}\Engine\Binaries\Win64\UnrealEditor.exe'
+    else:
+        exe_path = None
+
+    if UNREAL_EXE:
+        exe_path = UNREAL_EXE
+
+    if exe_path:
+        command = f'"{exe_path}" "{UNREAL_PROJECT}" -stdout -nopause -forcelogflush -verbose'
+        shell(
+            command, 
+            env={
+                **os.environ.copy(),
+                'UNREAL_APP_VERSION': version,
+                'UNREAL_DEBUGGING_ON': debug,
+                'UE_PYTHONPATH': ';'.join([
+                    *site.getsitepackages(),
+                    str(Path(poly_hammer_utils.__file__).parent.parent.absolute()), 
+                    str(UNREAL_STARTUP_SCRIPT.parent.absolute())
+                ])
+            }
+        )
+
+
+if __name__ == "__main__":
+    app_name = sys.argv[1]
+    app_version = sys.argv[2]
+    debug_on = sys.argv[3]
+
+    if app_name == 'blender':
+        launch_blender(
+            version=app_version,
+            debug=debug_on
+        )
+
+    if app_name == 'unreal':
+        launch_unreal(
+            version=app_version,
+            debug=debug_on
+        )