""" Copyright 2024 Netflix Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Module which contains the functionality to compile the python application into its platform-specific executable and installer """ import platform import os import shutil import subprocess import importlib.util import sys import xml.etree.ElementTree as ET from types import ModuleType from typing import List def get_current_folder() -> str: """ Get the current folder of this script Returns: The current folder of this script """ return os.path.dirname(os.path.realpath(__file__)) def get_src_folder() -> str: """ Get the src folder of this project Returns: The src folder of this project """ return os.path.join(get_current_folder(), "src") def get_python_package_folder() -> str: """ Get the python package folder of this project Returns: The python package folder of this project """ return os.path.join(get_src_folder(), "open_vp_cal") def import_module_from_filepath(filepath: str) -> ModuleType: """ Import a module from a given filepath Args: filepath: The filepath to the module to import Returns: The imported module """ spec = importlib.util.spec_from_file_location("module.name", filepath) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module def get_version_from_python_package() -> str: """ Get the version number from the python package Returns: The version number from the python package """ python_folder = get_python_package_folder() init_file = os.path.join(python_folder, "__init__.py") init_module = import_module_from_filepath(init_file) return init_module.__version__ def get_python_package_resource_folder() -> str: """ Get the python package resource folder of this project Returns: The python package resource folder of this project """ return os.path.join(get_python_package_folder(), "resources") def get_additional_data_from_resources() -> List[str]: """ Get a list of additional data flags for the --add-data command of the pyinstaller Returns: A list of additional data flags for the --add-data command of the pyinstaller """ add_data = [] platform_sep = get_additional_data_seperator() target_folder = os.path.join(".", "open_vp_cal", "resources", ".") resources_folder = get_python_package_resource_folder() resources = os.listdir(resources_folder) for resource in resources: input_file = os.path.join(resources_folder, resource) if os.path.isdir(input_file): continue add_data.append(f"{input_file}{platform_sep}{target_folder}") return add_data def get_additional_data_seperator() -> str: """ Get the path seperator used by pyinstaller for the platform we are running on Returns: The path seperator used by pyinstaller for the platform we are running on """ if platform.system() == 'Windows': return ";" return ":" def add_key_value_to_plist(plist_path: str, key_name: str, bool_value: bool) -> None: """ Adds a boolean value to the XML file, plist of the app when compiled on osx to force dak mode Args: plist_path: The path to the plist file key_name: The name of the key to add bool_value: The value of the key to add """ # Parse the existing XML file tree = ET.parse(plist_path) root = tree.getroot() # Assuming root is a 'plist' element, 'dict' will be the first child dict_element = root[0] # Now we can add a new key and boolean pair to the dict # We'll create a new 'key' element, and then a new 'true' or 'false' element immediately after it key_element = ET.SubElement(dict_element, 'key') key_element.text = key_name # The name of your key if bool_value: ET.SubElement(dict_element, 'true') else: ET.SubElement(dict_element, 'false') # Now the new key/value pair has been added to the XML data in memory # We can write the data back out to the Info.plist file tree.write(plist_path) def update_iscc_app_version(filename: str, new_version: str) -> None: """ Updates the version in the ISS file which is used to define the build process for the installer on windows Args: filename: The filename of the .iss filepath new_version: The new version we want to update too """ # Read the content of the file with open(filename, 'r') as file: content = file.read() # Replace the placeholder with the new version placeholder = '#define MyAppVersion "{}"'.format(new_version) updated_content = content.replace('#define MyAppVersion "0.0.1a"', placeholder) # Write the updated content back to the file with open(filename, 'w') as file: file.write(updated_content) def create_windows_installer(iss_file_path: str) -> int: """ Based on the given .iss file path, we run the inno setup compiler to create the window's installer Args: iss_file_path: The path to the .iss file to use to create the installer Returns: The return code of the inno setup compiler """ # Path to your Inno Setup Compiler - adjust if necessary inno_compiler_path = r"C:\Program Files (x86)\Inno Setup 6\ISCC.exe" # Create the command command = f'"{inno_compiler_path}" "{iss_file_path}"' # Execute the command process = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True) # Print output in real time while True: output = process.stdout.readline() if output == b'' and process.poll() is not None: break if output: print(output.strip().decode('utf-8')) # Wait for the process to finish and get the return code. return_code = process.wait() return return_code def check_python_is_64_bit() -> bool: """ Checks the version of python we have installed is 64 bit Returns: True if python is 64 bit, False if not """ return sys.maxsize > 2 ** 32 def check_python_version() -> bool: """ Checks the version of python we have installed is 3.11 Returns: True if python is 3.11, False if not """ major_minor_version = '.'.join(platform.python_version().split('.')[:2]) return '3.11' == major_minor_version def is_git_installed() -> bool: """ Checks if git is installed Returns: True if git is installed, False if not """ try: # The "stdout" and "stderr" arguments will make subprocess capture the output and error # The "shell" argument is set to True to run the command in the shell subprocess.check_output("git --version", stderr=subprocess.STDOUT, shell=True) return True except Exception: return False def git_clone(repo_url: str, target_dir: str) -> None: """ Clones the given git repo to the given target directory Args: repo_url: The url of the git repo to clone target_dir: The target directory to clone the repo to """ try: # Check if target_dir exists, if not, create it if not os.path.exists(target_dir): os.makedirs(target_dir) # Run the git clone command subprocess.check_call(['git', 'clone', repo_url, target_dir]) except subprocess.CalledProcessError as exception: raise RuntimeError(f"Git clone failed with error: {exception.output}") def run_vcpkg_bootstrap(folder_path: str) -> None: """ Runs the vcpkg bootstrap command for the given platform Args: folder_path: The path to the vcpkg folder """ try: # The command must be a list of strings, where each string is a command or argument # The "./vcpkg/bootstrap-vcpkg.bat" path should be adjusted to the correct path of your bat file if platform.system() == 'Windows': script_name = "bootstrap-vcpkg.bat" else: script_name = "bootstrap-vcpkg.sh" boot_strap_file = os.path.join(folder_path, script_name) subprocess.run([boot_strap_file], check=True) except subprocess.CalledProcessError as exception: raise RuntimeError("Vcpkg bootstrap failed: " + exception.output) def is_pkgconfig_installed() -> bool: """ Checks if pkg-config is installed on platforms which are not windows Returns: True if pkg-config is installed, False if not """ # Check if not running on Windows if platform.system() != 'Windows': try: # Check if pkg-config is available subprocess.run(['pkg-config', '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) return True except FileNotFoundError: return False return True def run_vcpkg_install(folder_path: str) -> None: """ Runs the vcpkg install command for the given platform Args: folder_path: The path to the vcpkg folder """ try: # Each part of the command is a separate item in the list # The "./vcpkg/vcpkg.exe" path should be adjusted to the correct path of your exe file args = [] if platform.system() == 'Windows': script_name = "vcpkg.exe" triplet = 'x64-windows-release' elif platform.system() == 'Darwin': script_name = "vcpkg" triplet = 'x64-osx' if platform.processor() == 'arm': triplet = 'arm64-osx' else: script_name = "vcpkg" triplet = 'x64-linux' vcpkg = os.path.join(folder_path, script_name) args.extend([vcpkg, 'install', 'openimageio[opencolorio,pybind11, freetype]', '--recurse', '--triplet', triplet]) subprocess.run( args, check=True) except subprocess.CalledProcessError as exception: raise RuntimeError("Vcpkg install failed:" + exception.output) def main() -> int: """ The main function which is called when this script is run Returns: The return code of the process """ check_dependencies() vcpkg_folder = get_vcpkg_root() setup_and_install_vcpkgs(vcpkg_folder) debug = False app_name = "OpenVPCal" version = get_version_from_python_package() icon_file_path = os.path.join(get_python_package_resource_folder(), "icon.ico") paths = get_python_package_folder() additional_data = get_additional_data_from_resources() entry_script = os.path.join(paths, "main.py") platform_sep = get_additional_data_seperator() additional_python_modules = { "spg": os.path.join(get_src_folder(), "spg"), "stageassets": os.path.join(get_src_folder(), "stageassets"), "spg_icvfxpatterns": os.path.join(get_src_folder(), "spg_icvfxpatterns") } if debug: cmds = ["pyinstaller", "--debug", "all"] else: cmds = ["pyinstaller"] if platform.system() != 'Windows': cmds.append("-w") cmds.extend( ["--icon", icon_file_path, "--name", app_name, "--noconfirm", "--clean", "--onedir", "--paths", paths] ) for folder_name, additional_module in additional_python_modules.items(): cmds.append("--add-data") cmds.append(f"{additional_module}{platform_sep}{folder_name}") for add_data in additional_data: cmds.append("--add-data") cmds.append(add_data) manual_paths = get_additional_library_paths(vcpkg_folder) for manual_path in manual_paths: cmds.append("--add-data") cmds.append(f"{manual_path}{platform_sep}.") cmds.append(entry_script) process = subprocess.Popen(cmds, stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True) print(process.stdout.read()) # Wait for the process to finish and get the return code. return_code = process.wait() if platform.system() == 'Darwin': certificate_name = os.getenv("CODE_SIGNING_CERTIFICATE", "") if certificate_name: return_code = osx_sign_app_and_build_dmg( app_name, certificate_name, version) else: print("WARNING - No CODE_SIGNING_CERTIFICATE environment variable set. Skipping code signing.") if platform.system() == 'Windows': return_code = build_windows_installer(manual_paths, version) print('Return code:', return_code) return return_code def get_additional_library_paths(vcpkg_folder: str) -> List[str]: """ Gets the additional library paths we need to include in the distribution Args: vcpkg_folder: The path to the vcpkg folder Returns: A list of additional library paths we need to include in the distribution """ manual_paths = [] library_root = None python_oiio_lib_folder = None if platform.system() == 'Windows': library_root = os.path.join(vcpkg_folder, "installed", "x64-windows-release", "bin") python_oiio_lib_folder = os.path.join( vcpkg_folder, "installed", "x64-windows-release", "lib", "python3.11", "site-packages", "OpenImageIO" ) elif platform.system() == 'Darwin': arch = "x64-osx" if platform.processor() == "arm": arch = "arm64-osx" library_root = os.path.join(vcpkg_folder, "installed", arch, "lib") python_oiio_lib_folder = os.path.join( library_root, "python3.11", "site-packages", "OpenImageIO" ) lib_files = os.listdir(library_root) for lib_file in lib_files: manual_paths.append(f"{library_root}/{lib_file}") for lib_file in os.listdir(python_oiio_lib_folder): if lib_file == "__init__.py": continue if lib_file == "__pycache__": continue manual_paths.append(f"{python_oiio_lib_folder}/{lib_file}") return manual_paths def build_windows_installer(manual_paths, version) -> int: """ Builds the window's installer and ensures the manual files are copied to the distribution folder Args: manual_paths: The third party library paths we need to include version: The version of the app we are building so we update the installer compilation instructions Returns: The return code of the process """ current_script_directory = get_current_folder() for manual_path in manual_paths: distribution_folder = os.path.join(current_script_directory, "dist", "OpenVPCal") target_file = os.path.join( distribution_folder, os.path.basename(manual_path) ) shutil.copy(manual_path, target_file) iss_file_name = os.path.join(current_script_directory, "OpenVPCal.iss") update_iscc_app_version(iss_file_name, version) return_code = create_windows_installer( iss_file_name ) return return_code def remove_ds_store(root_dir): for dir_path, dir_names, filenames in os.walk(root_dir): if '.DS_Store' in filenames: ds_store_path = os.path.join(dir_path, '.DS_Store') try: os.remove(ds_store_path) print(f'Successfully deleted: {ds_store_path}') except Exception as e: print(f'Failed to delete {ds_store_path}: {e}') def osx_sign_app_and_build_dmg(app_name: str, certificate_name: str, version: str) -> int: """ Signs the app and builds the dmg for osx Args: app_name: The app name certificate_name: The name of the certificate to sign the app version: The version number we are releasing """ arch = "universal" if platform.processor() == "arm": arch = "arm" current_script_directory = get_current_folder() app_path = os.path.join(current_script_directory, "dist/OpenVPCal.app") dmg_path = os.path.join(current_script_directory, f"dist/OpenVPCal-{version}-{arch}.dmg") remove_ds_store(app_path) # Ensure we pick up the system theme pinfo_file_path = os.path.join(app_path, "Contents", "Info.plist") add_key_value_to_plist(pinfo_file_path, "NSRequiresAquaSystemAppearance", False) # Sign The .App # Resign The App As We Changed The pList app_path_executable = os.path.join(app_path, "Contents", "MacOS", app_name) print("Re Signing The App") process = subprocess.Popen(["codesign", "--deep", "--force", "--sign", certificate_name, app_path_executable], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True) print(process.stdout.read()) # Wait for the process to finish process.wait() print("Creating The DMG") process = subprocess.Popen(["hdiutil", "create", "-srcfolder", app_path, dmg_path], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True) print(process.stdout.read()) # Wait for the process to finish and get the return code. process.wait() # Code Sign The DMG also print("Signing The DMG") process = subprocess.Popen(["codesign", "--sign", certificate_name, dmg_path], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True) print(process.stdout.read()) # Wait for the process to finish and get the return code. return_code = process.wait() return return_code def setup_and_install_vcpkgs(vcpkg_folder: str) -> None: """ Sets up and installs the vcpkgs for the given platform Args: vcpkg_folder: The path to the vcpkg folder """ if not os.path.exists(vcpkg_folder): os.makedirs(vcpkg_folder) git_clone('https://github.com/microsoft/vcpkg', vcpkg_folder) run_vcpkg_bootstrap(vcpkg_folder) run_vcpkg_install(vcpkg_folder) def get_vcpkg_root() -> str: """ Get the root folder of vcpkg Returns: The root folder of vcpkg """ if platform.system() == 'Windows': root_folder = "D:\\" else: root_folder = os.path.expanduser("~") vcpkg_folder = os.path.join(root_folder, "vcpkg") return vcpkg_folder def check_dependencies() -> None: """ Checks the dependencies of this script are met before it runs """ if not check_python_is_64_bit(): raise RuntimeError("Python must be 64 bit") if not check_python_version(): raise RuntimeError("Python must be 3.11") if not is_git_installed(): raise RuntimeError("Git must be installed") if not is_pkgconfig_installed(): raise RuntimeError("pkg-config must be installed") if __name__ == "__main__": main()