def bind(path, version_range=None, opts=None, parser=None): rez_version = Version(rez.__version__) check_version(rez_version, version_range) rez_major_version = rez_version.trim(1) rez_major_minor_version = rez_version.trim(2) next_major = int(str(rez_major_version)) + 1 rez_req_str = "rez-%s+<%d" % (str(rez_major_minor_version), next_major) gui_lib = getattr(opts, "gui_lib", "") def make_root(variant, root): # copy source rez_path = rez.__path__[0] site_path = os.path.dirname(rez_path) rezgui_path = os.path.join(site_path, "rezgui") shutil.copytree(rezgui_path, os.path.join(root, "rezgui")) # create rez-gui executable binpath = make_dirs(root, "bin") filepath = os.path.join(binpath, "rez-gui") create_executable_script(filepath, rez_gui_source) # create package with make_package("rezgui", path, make_root=make_root) as pkg: pkg.version = rez_version pkg.variants = [system.variant] pkg.commands = commands pkg.tools = ["rez-gui"] pkg.requires = [rez_req_str] if gui_lib: pkg.requires.append(gui_lib) return "rezgui", rez_version
def bind(path, version_range=None, opts=None, parser=None): # find executable, determine version if opts and opts.exe: exepath = find_exe("python", opts.exe) code = "import sys; print '.'.join(str(x) for x in sys.version_info)" version = extract_version(exepath, ["-c", code]) else: exepath = sys.executable strver = '.'.join(str(x) for x in sys.version_info[:3]) version = Version(strver) check_version(version, version_range) def make_root(variant, root): binpath = make_dirs(root, "bin") link = os.path.join(binpath, "python") platform_.symlink(exepath, link) with make_package("python", path, make_root=make_root) as pkg: pkg.version = version pkg.tools = ["python"] pkg.commands = commands pkg.variants = [system.variant] return "python", version
def bind(path, version_range=None, opts=None, parser=None): # find executable, determine version exepath = find_exe("python", opts.exe) code = "import sys;print('.'.join(str(x) for x in sys.version_info))" version = extract_version(exepath, ["-c", code]) check_version(version, version_range) log("binding python: %s" % exepath) def make_root(variant, root): bindir = make_dirs(root, "bin") if os.name == "nt": fname = os.path.join(bindir, "python.bat") with open(fname, "w") as f: f.write(bat.format(python=exepath)) else: fname = os.path.join(bindir, "python") with open(fname, "w") as f: f.write(sh.format(python=exepath)) # Make executable st = os.stat(fname) os.chmod(fname, st.st_mode | stat.S_IEXEC) with make_package("python", path, make_root=make_root) as pkg: pkg.version = version pkg.tools = ["python"] pkg.commands = commands pkg.variants = [system.variant] pkg.exe = exepath return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None): # find executable, determine version if opts and opts.exe: exepath = find_exe("python", opts.exe) code = "import sys; print '.'.join(str(x) for x in sys.version_info)" version = extract_version(exepath, ["-c", code]) else: exepath = sys.executable strver = '.'.join(str(x) for x in sys.version_info[:3]) version = Version(strver) check_version(version, version_range) def make_root(variant, root): if platform_.name != 'windows': binpath = make_dirs(root, "bin") link = os.path.join(binpath, "python") platform_.symlink(exepath, link) with make_package("python", path, make_root=make_root) as pkg: pkg.version = version pkg.tools = ["python"] if platform_.name == 'windows': pkg.commands = win_commands(exepath) else: pkg.commands = nix_commands pkg.variants = [system.variant] return "python", version
def bind(path, version_range=None, opts=None, parser=None): version = Version(system.arch) check_version(version, version_range) with make_package("arch", path) as pkg: pkg.version = version return ("arch", version)
def bind(path, version_range=None, opts=None, parser=None): version = Version(system.platform) check_version(version, version_range) with make_package("platform", path) as pkg: pkg.version = version return "platform", version
def bind(path, version_range=None, opts=None, parser=None): version = Version(system.arch) check_version(version, version_range) with make_package("arch", path) as pkg: pkg.version = version return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None): version = Version(system.os) check_version(version, version_range) with make_package("os", path) as pkg: pkg.version = version pkg.requires = ["platform-%s" % system.platform, "arch-%s" % system.arch] return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None): versions = ["AMD64", "AMD86"] for version in versions: version = Version(version) check_version(version, version_range) with make_package("target", path) as pkg: pkg.version = version return ("target", versions)
def bind(path, version_range=None, opts=None, parser=None): version = Version(system.os) check_version(version, version_range) with make_package("os", path) as pkg: pkg.version = version pkg.requires = [ "platform-%s" % system.platform, "arch-%s" % system.arch ] return "os", version
def bind(path, version_range=None, opts=None, parser=None): # find executable, determine version exepath = find_exe("python", opts.exe) code = "import sys; print '.'.join(str(x) for x in sys.version_info)" version = extract_version(exepath, ["-c", code]) check_version(version, version_range) log("binding python: %s" % exepath) # find builtin modules builtin_paths = {} entries = [("lib", "os"), ("extra", "setuptools")] for dirname, module_name in entries: success, out, err = run_python_command([ "import %s" % module_name, "print %s.__file__" % module_name]) if success: pypath = os.path.dirname(out) if os.path.basename(pypath) == module_name: pypath = os.path.dirname(pypath) if pypath not in builtin_paths.values(): builtin_paths[dirname] = pypath # make the package # def make_root(variant, root): binpath = make_dirs(root, "bin") link = os.path.join(binpath, "python") platform_.symlink(exepath, link) if builtin_paths: pypath = make_dirs(root, "python") for dirname, srcpath in builtin_paths.iteritems(): destpath = os.path.join(pypath, dirname) log("Copying builtins from %s to %s..." % (srcpath, destpath)) shutil.copytree(srcpath, destpath) with make_package("python", path, make_root=make_root) as pkg: pkg.version = version pkg.tools = ["python"] pkg.commands = commands pkg.variants = [system.variant] if builtin_paths: pkg.post_commands = post_commands return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None): version = Version(system.os) check_version(version, version_range) with make_package("os", path) as pkg: pkg.version = version pkg.requires = [ "platform-%s" % system.platform, "arch-%s" % system.arch ] pkg.relocatable = True return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None): version = Version("1.0") check_version(version, version_range) def make_root(variant, root): binpath = make_dirs(root, "bin") filepath = os.path.join(binpath, "hello_world") create_executable_script(filepath, hello_world_source) with make_package("hello_world", path, make_root=make_root) as pkg: pkg.version = version pkg.tools = ["hello_world"] pkg.commands = commands return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None): exepath = find_exe("cmake", getattr(opts, "exe", None)) version = extract_version(exepath, "--version") check_version(version, version_range) def make_root(variant, root): binpath = make_dirs(root, "bin") link = os.path.join(binpath, "cmake") platform_.symlink(exepath, link) with make_package("cmake", path, make_root=make_root) as pkg: pkg.version = version pkg.tools = ["cmake"] pkg.commands = commands pkg.variants = [system.variant] return "cmake", version
def bind(path, version_range=None, opts=None, parser=None): is_win64 = False if os.environ.get('PROCESSOR_ARCHITECTURE','x86') != 'x86': is_win64 = True if os.environ.get('PROCESSOR_ARCHITEW6432'): is_win64 = True if os.environ.get('ProgramW6432'): is_win64 = True msvcs = enumerate_msvc(is_win64) if not msvcs: version = getattr(opts, "version", None) if not version: _msvc_root = getattr(opts, "root", None) if not _msvc_root: print "can't find msvc root, use --root and pass the directory to find vcvarsall.bat" exit(1) else: vcvarsall = os.path.join(_msvc_root, "vcvarsall.bat") if not os.path.isfile(vcvarsall): print "can't find:", vcvarsall exit(1) version = os.path.split(_msvc_root)[-2].split()[-1] msvcs[version] = _msvc_root for variant in ['target-AMD64', 'target-AMD86']: variants = system.variant+[variant] for version, msvc_root in msvcs.iteritems(): check_version(version, version_range) def make_root(variant, root): binpath = make_dirs(root, "bin") bat = os.path.join(binpath, "setupmsvc.bat") with open(bat, "w") as f: f.write(setupmsvc.format(msvc_root=msvc_root)) with make_package("msvc", path, make_root=make_root) as pkg: pkg.version = version pkg.tools = ["setupmsvc"] pkg.commands = commands pkg.variants = [variants] return "msvc", msvcs.keys()
def bind(path, version_range=None, opts=None, parser=None): # find executable, determine version exepath = find_exe("python", opts.exe) code = "import sys;print('.'.join(str(x) for x in sys.version_info))" version = extract_version(exepath, ["-c", code]) check_version(version, version_range) log("binding python: %s" % exepath) def make_root(variant, root): make_dirs(root, "python") with make_package("python", path, make_root=make_root) as pkg: pkg.version = version pkg.tools = ["python"] pkg.commands = commands pkg.variants = [system.variant] pkg.exe = exepath return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None): version = rez.__version__ check_version(version, version_range) def make_root(variant, root): # copy source rez_path = rez.__path__[0] site_path = os.path.dirname(rez_path) rezplugins_path = os.path.join(site_path, "rezplugins") shutil.copytree(rez_path, os.path.join(root, "rez")) shutil.copytree(rezplugins_path, os.path.join(root, "rezplugins")) with make_package("rez", path, make_root=make_root) as pkg: pkg.version = version pkg.commands = commands pkg.requires = ["python-2.6+<3"] pkg.variants = [system.variant] return "rez", version
def bind(path, version_range=None, opts=None, parser=None): # find executable, determine version if opts and opts.root: bin_path = opts.root else: possible_paths = [r'C:\Program Files (x86)\QuickTime'] for root_path in possible_paths: if os.path.exists(root_path): bin_path = root_path break else: raise EnvironmentError( 'Unable to find Quicktime on this system in the paths; {}'.format( ', '.join(possible_paths) ) ) if platform_.name == 'windows': from win32api import GetFileVersionInfo, LOWORD, HIWORD try: info = GetFileVersionInfo(os.path.join(bin_path, 'QuickTimePlayer.exe'), "\\") ms = info['FileVersionMS'] ls = info['FileVersionLS'] version = Version('{}.{}.{}.{}'.format(HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) except: raise EnvironmentError('Unknown version') else: raise EnvironmentError('Only binds on windows at the moment') check_version(version, version_range) with make_package("quicktime", path) as pkg: pkg.version = version if platform_.name == 'windows': pkg.tools = ["QuickTimePlayer.exe"] pkg.commands = win_commands(bin_path) else: raise EnvironmentError('Only binds on windows at the moment') pkg.variants = [system.variant] return "quicktime", version
def bind(path, version_range=None, opts=None, parser=None): version = Version(system.platform) check_version(version, version_range) def post_commands(): """Setup default XDG_* environment variables. https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html#variables """ import os xdg_defaults = ( ('XDG_DATA_HOME', ['$HOME/.local/share']), ('XDG_DATA_DIRS', ['/usr/local/share', '/usr/share']), ('XDG_CONFIG_HOME', ['$HOME/.config']), ('XDG_CONFIG_DIRS', ['/etc/xdg']), ('XDG_CACHE_HOME', ['$HOME/.cache']), ) for xdg_var, defaults in xdg_defaults: invalid_var = undefined(xdg_var) or not str(env[xdg_var]) paths = [] if invalid_var else str(env[xdg_var]).split(os.pathsep) append = len(defaults) != 1 for default_path in defaults: expanded = expandvars(default_path) if not (default_path in paths or expanded in paths): if append: env[xdg_var].append(expanded) else: env[xdg_var] = expanded with make_package("platform", path) as pkg: pkg.version = version pkg.relocatable = True if system.platform == 'linux': pkg.post_commands = post_commands return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None): if platform_.name != 'windows': raise EnvironmentError('Only binds on windows at the moment') # find executable, determine version if opts and opts.root: bin_path = opts.root else: installed_versions = [] autodesk_root = r'C:\Program Files\Autodesk' for app_folder in os.listdir(autodesk_root): if app_folder.startswith('3ds Max'): installed_versions.append( (app_folder, Version(app_folder.replace('3ds Max', '').strip()))) if len(installed_versions) < 1: raise EnvironmentError( 'Unable to find any installed version of 3ds Max under "{}"'. format(autodesk_root)) app_folder, version = sorted(installed_versions, key=lambda v: v[1])[-1] bin_path = os.path.join(autodesk_root, app_folder) from win32api import GetFileVersionInfo, LOWORD, HIWORD try: info = GetFileVersionInfo(os.path.join(bin_path, '3dsmax.exe'), "\\") ms = info['FileVersionMS'] ls = info['FileVersionLS'] version = Version('{}.{}.{}.{}'.format(HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) except: raise EnvironmentError('Unknown version') check_version(version, version_range) def make_root(resources_path, variant, path): import shutil shutil.copy(os.path.join(resources_path, '3dsmax_icon.png'), os.path.join(path, '3dsmax_icon.png')) make_root_partial = functools.partial( make_root, resource_filename(Requirement.parse('rez'), "rez/bind/resources")) with make_package("3dsmax", path, make_root=make_root_partial) as pkg: pkg.version = version pkg.tools = ["3dsmax"] pkg.description = '3D DCC application' pkg.authors = ['Autodesk'] pkg.requires = ['roaming_user'] pkg.nice_name = '3DS Max' pkg.tools_info = { '3dsmax': { 'command': [ 'start', '3DSMax', '/D', '%ADSK_3DSMAX_x64_2015%', '/wait', '/B', '3dsmax.exe' ], 'nice_name': '3ds Max', 'priority': 89, 'icon': '{root}/3dsmax_icon.png', 'launch_in_prompt': False } } pkg.commands = win_commands(bin_path) pkg.variants = [system.variant] return "3dsmax", version
def bind(path, version_range=None, opts=None, parser=None): if opts and opts.pypkg: py_package_name = opts.pypkg if opts.name: package_name = opts.name else: package_name = py_package_name.replace('-', '_') else: raise ValueError('A package name needs to be specified') # connect to PyPi and get the released package versions pypi_client = xmlrpclib.ServerProxy('https://pypi.python.org/pypi') package_versions = sorted(pypi_client.package_releases(py_package_name), key=lambda v: Version(v)) if len(package_versions) < 1: raise ValueError('Invalid package name: {}'.format(package_name)) # get the version if opts.version: version = next((v for v in package_versions if v == opts.version), None) if version is None: raise ValueError('Invalid version: {}, valid versions: {}'.format( opts.version, package_versions)) else: version = package_versions[-1] check_version(Version(version), version_range) # get the source distribution, this could be better and try to install wheels as well release_info = next( (r for r in pypi_client.release_urls(py_package_name, version) if r['packagetype'] == 'sdist'), None) if release_info is None: raise ValueError( 'No source distribution (we don\'t support wheels at the moment) for {} {}' .format(py_package_name, version)) # clear the temp dir if it exists tmp_dir = os.path.join(platform_.tmpdir, package_name) if os.path.exists(tmp_dir): shutil.rmtree(tmp_dir) os.mkdir(tmp_dir) # download file to tmp dir handle = urllib2.urlopen(release_info['url']) src_archive = os.path.join(tmp_dir, release_info['filename']) with open(src_archive, 'wb') as src_archive_fp: src_archive_fp.write(handle.read()) # decompress the file package_dir = None if release_info['filename'].endswith('.zip'): zfile = zipfile.ZipFile(src_archive, 'r') zfile.extractall(tmp_dir) package_dir = src_archive.replace('.zip', '') elif release_info['filename'].endswith('.tar.gz'): tfile = tarfile.open(src_archive, 'r:gz') tfile.extractall(tmp_dir) package_dir = src_archive.replace('.tar.gz', '') elif release_info['filename'].endswith('.tgz'): tfile = tarfile.open(src_archive, 'r:gz') tfile.extractall(tmp_dir) package_dir = src_archive.replace('.tgz', '') else: raise ValueError( 'Package file downloaded cannot be decompressed: {}'.format( src_archive)) setup_file = os.path.join(package_dir, 'setup.py') if not os.path.exists(setup_file): raise RuntimeError( 'Package does not contain a "setup.py" file in the root of the archive: {}' .format(py_package_name)) def setup_dummy(*args, **kwargs): global SETUPTOOLS_ARGS SETUPTOOLS_ARGS = {} if 'scripts' in kwargs: SETUPTOOLS_ARGS['scripts'] = kwargs['scripts'] if 'description' in kwargs: SETUPTOOLS_ARGS['description'] = kwargs['description'] if 'long_description' in kwargs: SETUPTOOLS_ARGS['long_description'] = kwargs['long_description'] if 'author' in kwargs: SETUPTOOLS_ARGS['author'] = kwargs['author'] if 'author_email' in kwargs: SETUPTOOLS_ARGS['author_email'] = kwargs['author_email'] if 'install_requires' in kwargs: SETUPTOOLS_ARGS['install_requires'] = kwargs['install_requires'] if 'setup_requires' in kwargs: SETUPTOOLS_ARGS['setup_requires'] = kwargs['setup_requires'] if 'version' in kwargs: SETUPTOOLS_ARGS['version'] = kwargs['version'] else: raise RuntimeError('A package must have a version.') # monkey patch the setup function so we can steal the arguments passed to it setuptools.setup = setup_dummy distutils.core.setup = setup_dummy cwd = os.getcwd() os.chdir(package_dir) sys.path.extend([package_dir]) old_args = sys.argv[:] try: _ = imp.load_source('{}_setup'.format(package_name), setup_file) except Exception as e: import traceback traceback.print_exc() raise e sys.argv = old_args[:] os.chdir(cwd) sys.path.remove(package_dir) def parse_setup_requirements(req_str): ''' e.g. "arrow >= 0.4.4, < 1" -> 'arrow-0.4.4+<1 :param req_str: requirement in the setuptools format :return: requirement in the rez format ''' if not any((op in req_str for op in ['<', '>', '='])): # even simpler "arrow" req return req_str.replace('-', '_').strip() if '==' in req_str: # just a simple "arrow == 0.4.4" req req_pgk_name, req_version = req_str.split('==') return '{}-{}'.format( req_pgk_name.replace('-', '_').strip(), req_version.strip()) complex_req_match = re.match( r'^(?P<pkg_name>[a-zA-Z0-9\.-_]+) *(?P<reqs>[\.,<>=0-9) ]+)$', req_str.strip()) if not complex_req_match: raise RuntimeError( 'Unable to parse requirement; {}'.format(req_str)) req_pgk_name = complex_req_match.group('pkg_name') req_pgk_req_str = complex_req_match.group('reqs') requirements = map(lambda s: s.strip(), req_pgk_req_str.split(',')) versions_rewrite = [] for sub_requirement_str in requirements: sub_requirement_match = re.match(r'([<>=]+?) ?([0-9a-zA-Z\.]+)', sub_requirement_str) operation = sub_requirement_match.group(1).strip() req_version = sub_requirement_match.group(2).strip() if operation == '>=': versions_rewrite.insert(0, '{}+'.format(req_version)) elif operation == '<': versions_rewrite.append('<{}'.format(req_version)) else: raise RuntimeError( 'Unable to translate operation: "{}" in requirement: {}'. format(operation, req_str)) return '{}-{}'.format(req_pgk_name.replace('-', '_'), ''.join(versions_rewrite)) def make_root(variant, root): binpath = make_dirs(root, "bin") pythonpath = make_dirs(root, "python") headerpath = make_dirs(root, "include") install_cmd = ' '.join([ 'pip', 'install', '--no-deps', '--ignore-installed', '--verbose', '--verbose', '--verbose', '--global-option="--verbose"', '--install-option="--install-headers={}"'.format(headerpath), '--install-option="--install-purelib={}"'.format(pythonpath), '--install-option="--install-platlib={}"'.format(pythonpath), '--install-option="--install-scripts={}"'.format(binpath), py_package_name ]) try: subprocess.check_output(install_cmd, cwd=package_dir) except subprocess.CalledProcessError as _: raise RuntimeError( 'Bind failed to install python package with command: {}'. format(install_cmd)) with make_package(package_name, path, make_root=make_root) as pkg: pkg.version = version if 'description' in SETUPTOOLS_ARGS: if len(SETUPTOOLS_ARGS['description']) < 150: pkg.nice_name = SETUPTOOLS_ARGS['description'] else: pkg.nice_name = SETUPTOOLS_ARGS['description'][:147] + '...' if 'long_description' in SETUPTOOLS_ARGS: pkg.description = SETUPTOOLS_ARGS['long_description'] author_parts = [] if 'author' in SETUPTOOLS_ARGS: author_parts.append(SETUPTOOLS_ARGS['author']) if 'author_email' in SETUPTOOLS_ARGS: author_parts.append(SETUPTOOLS_ARGS['author_email']) if len(author_parts) > 0: pkg.authors = [' '.join(author_parts)] else: pkg.authors = [] if 'install_requires' in SETUPTOOLS_ARGS: pkg.requires = [ parse_setup_requirements(req) for req in SETUPTOOLS_ARGS['install_requires'] ] else: pkg.requires = [] if 'setup_requires' in SETUPTOOLS_ARGS: pkg.build_requires = [ parse_setup_requirements(req) for req in SETUPTOOLS_ARGS['setup_requires'] ] if 'scripts' in SETUPTOOLS_ARGS: pkg.tools = [ os.path.split(script)[-1] for script in SETUPTOOLS_ARGS['scripts'] ] pkg.commands = commands return package_name, Version(version)
def bind(path, version_range=None, opts=None, parser=None): if platform_.name != 'windows': raise EnvironmentError('Only binds on windows at the moment') # # find executable, determine version # if opts and opts.root: # root_path = opts.root # try: # info = GetFileVersionInfo(os.path.join(root_path, 'bin', 'deadlinecommand.exe'), "\\") # ms = info['FileVersionMS'] # ls = info['FileVersionLS'] # version = Version('{}.{}.{}.{}'.format(HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) # except: # raise EnvironmentError('Unknown version') # else: installed_versions = [] thinkbox_root = r'C:\Program Files\Thinkbox' app_folder_prefix = 'Deadline7' # previous value was 'Deadline' with no number for app_folder in os.listdir(thinkbox_root): if app_folder.startswith(app_folder_prefix): app_exe = os.path.join(thinkbox_root, app_folder, 'bin', 'deadlinecommand.exe') if os.path.exists(app_exe): try: info = GetFileVersionInfo(app_exe, "\\") ms = info['FileVersionMS'] ls = info['FileVersionLS'] version = Version('{}.{}.{}.{}'.format(HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) except: raise EnvironmentError('Unknown version') installed_versions.append( (app_folder, version) ) if len(installed_versions) < 1: raise EnvironmentError( 'Unable to find any installed version of Deadline under "{}"'.format( thinkbox_root ) ) app_folder, version = sorted(installed_versions, key=lambda v: v[1])[-1] root_path = os.path.join(thinkbox_root, app_folder, 'bin') check_version(version, version_range) def make_root(resources_path, variant, path): import shutil shutil.copy( os.path.join(resources_path, 'deadline_monitor_icon.png'), os.path.join(path, 'deadline_monitor_icon.png') ) make_root_partial = functools.partial(make_root, resource_filename(Requirement.parse('rez'), "rez/bind/resources")) with make_package("deadline", path, make_root=make_root_partial) as pkg: pkg.version = version pkg.tools = ["monitor"] pkg.description = 'Render Manager' pkg.authors = ['Thinkbox'] pkg.requires = [] pkg.nice_name = 'Deadline' pkg.tools_info = { 'monitor': { 'command': ['deadlinemonitor.exe'], 'nice_name': 'Monitor', 'priority': 89, 'icon': '{root}/deadline_monitor_icon.png', 'launch_in_prompt': False } } pkg.commands = win_commands(root_path, version.major) pkg.variants = [system.variant] return "deadline", version
def bind(name, path, import_name=None, version_range=None, version=None, requires=None, pure_python=None, tools=None, extra_module_names=[], extra_attrs={}): import_name = import_name or name if version is None: version = get_version_in_python( name, ["import %s" % import_name, "print %s.__version__" % import_name]) check_version(version, version_range) py_major_minor = '.'.join(str(x) for x in sys.version_info[:2]) py_req = "python-%s" % py_major_minor found_tools = {} if pure_python is None: raise NotImplementedError # detect elif pure_python: variant = [py_req] else: variant = system.variant + [py_req] for tool in (tools or []): try: src = find_exe(tool) found_tools[tool] = src log("found tool '%s': %s" % (tool, src)) except RezBindError as e: print_warning(str(e)) def make_root(variant, root): pypath = make_dirs(root, "python") copy_module(import_name, pypath) if found_tools: binpath = make_dirs(root, "bin") for tool, src in sorted(found_tools.items()): dest = os.path.join(binpath, tool) shutil.copy2(src, dest) for name_ in extra_module_names: copy_module(name_, pypath) with make_package(name, path, make_root=make_root) as pkg: pkg.version = version pkg.variants = [variant] if requires: pkg.requires = requires if found_tools: pkg.tools = list(found_tools) pkg.commands = commands_with_bin else: pkg.commands = commands for key, value in extra_attrs.iteritems(): pkg[key] = value return pkg.installed_variants
def bind(path, version_range=None, opts=None, parser=None): if platform_.name != 'windows': raise EnvironmentError('Only binds on windows at the moment') # find executable, determine version if opts and opts.root: bin_path = opts.root else: installed_versions = [] autodesk_root = r'C:\Program Files\Autodesk' for app_folder in os.listdir(autodesk_root): if app_folder.startswith('Mudbox'): installed_versions.append( (app_folder, Version(app_folder.replace('Mudbox', '').strip())) ) if len(installed_versions) < 1: raise EnvironmentError( 'Unable to find any installed version of Mudbox under "{}"'.format( autodesk_root ) ) app_folder, version = sorted(installed_versions, key=lambda v: v[1])[-1] bin_path = os.path.join(autodesk_root, app_folder) from win32api import GetFileVersionInfo, LOWORD, HIWORD try: info = GetFileVersionInfo(os.path.join(bin_path, 'mudbox.exe'), "\\") ms = info['FileVersionMS'] ls = info['FileVersionLS'] version = Version('{}.{}.{}.{}'.format(HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) except: raise EnvironmentError('Unknown version') check_version(version, version_range) def make_root(resources_path, variant, path): import shutil shutil.copy( os.path.join(resources_path, 'mudbox_icon.png'), os.path.join(path, 'mudbox_icon.png') ) make_root_partial = functools.partial(make_root, resource_filename(Requirement.parse('rez'), "rez/bind/resources")) with make_package("mudbox", path, make_root=make_root_partial) as pkg: pkg.version = version pkg.tools = ["mudbox"] pkg.description = 'Scupting application' pkg.authors = ['Autodesk'] pkg.requires = ['roaming_user'] pkg.nice_name = 'Mudbox' pkg.tools_info = { 'mudbox': { 'command': ['mudbox'], 'nice_name': 'Mudbox', 'priority': 89, 'icon': '{root}/mudbox_icon.png', 'launch_in_prompt': False } } pkg.commands = win_commands(bin_path) pkg.variants = [system.variant] return "mudbox", version
def bind(path, version_range=None, opts=None, parser=None): if opts and opts.pypkg: py_package_name = opts.pypkg if opts.name: package_name = opts.name else: package_name = py_package_name.replace('-', '_') else: raise ValueError('A package name needs to be specified') # connect to PyPi and get the released package versions pypi_client = xmlrpclib.ServerProxy('https://pypi.python.org/pypi') package_versions = sorted(pypi_client.package_releases(py_package_name), key=lambda v: Version(v)) if len(package_versions) < 1: raise ValueError('Invalid package name: {}'.format(package_name)) # get the version if opts.version: version = next((v for v in package_versions if v == opts.version), None) if version is None: raise ValueError('Invalid version: {}, valid versions: {}'.format(opts.version, package_versions)) else: version = package_versions[-1] check_version(Version(version), version_range) # get the source distribution, this could be better and try to install wheels as well release_info = next( (r for r in pypi_client.release_urls(py_package_name, version) if r['packagetype'] == 'sdist'), None ) if release_info is None: raise ValueError( 'No source distribution (we don\'t support wheels at the moment) for {} {}'.format(py_package_name, version) ) # clear the temp dir if it exists tmp_dir = os.path.join(platform_.tmpdir, package_name) if os.path.exists(tmp_dir): shutil.rmtree(tmp_dir) os.mkdir(tmp_dir) # download file to tmp dir handle = urllib2.urlopen(release_info['url']) src_archive = os.path.join(tmp_dir, release_info['filename']) with open(src_archive, 'wb') as src_archive_fp: src_archive_fp.write(handle.read()) # decompress the file package_dir = None if release_info['filename'].endswith('.zip'): zfile = zipfile.ZipFile(src_archive, 'r') zfile.extractall(tmp_dir) package_dir = src_archive.replace('.zip', '') elif release_info['filename'].endswith('.tar.gz'): tfile = tarfile.open(src_archive, 'r:gz') tfile.extractall(tmp_dir) package_dir = src_archive.replace('.tar.gz', '') elif release_info['filename'].endswith('.tgz'): tfile = tarfile.open(src_archive, 'r:gz') tfile.extractall(tmp_dir) package_dir = src_archive.replace('.tgz', '') else: raise ValueError('Package file downloaded cannot be decompressed: {}'.format(src_archive)) setup_file = os.path.join(package_dir, 'setup.py') if not os.path.exists(setup_file): raise RuntimeError( 'Package does not contain a "setup.py" file in the root of the archive: {}'.format(py_package_name) ) def setup_dummy(*args, **kwargs): global SETUPTOOLS_ARGS SETUPTOOLS_ARGS = {} if 'scripts' in kwargs: SETUPTOOLS_ARGS['scripts'] = kwargs['scripts'] if 'description' in kwargs: SETUPTOOLS_ARGS['description'] = kwargs['description'] if 'long_description' in kwargs: SETUPTOOLS_ARGS['long_description'] = kwargs['long_description'] if 'author' in kwargs: SETUPTOOLS_ARGS['author'] = kwargs['author'] if 'author_email' in kwargs: SETUPTOOLS_ARGS['author_email'] = kwargs['author_email'] if 'install_requires' in kwargs: SETUPTOOLS_ARGS['install_requires'] = kwargs['install_requires'] if 'setup_requires' in kwargs: SETUPTOOLS_ARGS['setup_requires'] = kwargs['setup_requires'] if 'version' in kwargs: SETUPTOOLS_ARGS['version'] = kwargs['version'] else: raise RuntimeError('A package must have a version.') # monkey patch the setup function so we can steal the arguments passed to it setuptools.setup = setup_dummy distutils.core.setup = setup_dummy cwd = os.getcwd() os.chdir(package_dir) sys.path.extend([package_dir]) old_args = sys.argv[:] try: _ = imp.load_source('{}_setup'.format(package_name), setup_file) except Exception as e: import traceback traceback.print_exc() raise e sys.argv = old_args[:] os.chdir(cwd) sys.path.remove(package_dir) def parse_setup_requirements(req_str): ''' e.g. "arrow >= 0.4.4, < 1" -> 'arrow-0.4.4+<1 :param req_str: requirement in the setuptools format :return: requirement in the rez format ''' if not any((op in req_str for op in ['<', '>', '='])): # even simpler "arrow" req return req_str.replace('-', '_').strip() if '==' in req_str: # just a simple "arrow == 0.4.4" req req_pgk_name, req_version = req_str.split('==') return '{}-{}'.format(req_pgk_name.replace('-', '_').strip(), req_version.strip()) complex_req_match = re.match(r'^(?P<pkg_name>[a-zA-Z0-9\.-_]+) *(?P<reqs>[\.,<>=0-9) ]+)$', req_str.strip()) if not complex_req_match: raise RuntimeError('Unable to parse requirement; {}'.format(req_str)) req_pgk_name = complex_req_match.group('pkg_name') req_pgk_req_str = complex_req_match.group('reqs') requirements = map(lambda s: s.strip(), req_pgk_req_str.split(',')) versions_rewrite = [] for sub_requirement_str in requirements: sub_requirement_match = re.match(r'([<>=]+?) ?([0-9a-zA-Z\.]+)', sub_requirement_str) operation = sub_requirement_match.group(1).strip() req_version = sub_requirement_match.group(2).strip() if operation == '>=': versions_rewrite.insert(0, '{}+'.format(req_version)) elif operation == '<': versions_rewrite.append('<{}'.format(req_version)) else: raise RuntimeError('Unable to translate operation: "{}" in requirement: {}'.format(operation, req_str)) return '{}-{}'.format(req_pgk_name.replace('-', '_'), ''.join(versions_rewrite)) def make_root(variant, root): binpath = make_dirs(root, "bin") pythonpath = make_dirs(root, "python") headerpath = make_dirs(root, "include") install_cmd = ' '.join([ 'pip', 'install', '--no-deps', '--ignore-installed', '--verbose', '--verbose', '--verbose', '--global-option="--verbose"', '--install-option="--install-headers={}"'.format(headerpath), '--install-option="--install-purelib={}"'.format(pythonpath), '--install-option="--install-platlib={}"'.format(pythonpath), '--install-option="--install-scripts={}"'.format(binpath), py_package_name ]) try: subprocess.check_output( install_cmd, cwd=package_dir ) except subprocess.CalledProcessError as _: raise RuntimeError('Bind failed to install python package with command: {}'.format(install_cmd)) with make_package(package_name, path, make_root=make_root) as pkg: pkg.version = version if 'description' in SETUPTOOLS_ARGS: if len(SETUPTOOLS_ARGS['description']) < 150: pkg.nice_name = SETUPTOOLS_ARGS['description'] else: pkg.nice_name = SETUPTOOLS_ARGS['description'][:147] + '...' if 'long_description' in SETUPTOOLS_ARGS: pkg.description = SETUPTOOLS_ARGS['long_description'] author_parts = [] if 'author' in SETUPTOOLS_ARGS: author_parts.append(SETUPTOOLS_ARGS['author']) if 'author_email' in SETUPTOOLS_ARGS: author_parts.append(SETUPTOOLS_ARGS['author_email']) if len(author_parts) > 0: pkg.authors = [' '.join(author_parts)] else: pkg.authors = [] if 'install_requires' in SETUPTOOLS_ARGS: pkg.requires = [parse_setup_requirements(req) for req in SETUPTOOLS_ARGS['install_requires']] else: pkg.requires = [] if 'setup_requires' in SETUPTOOLS_ARGS: pkg.build_requires = [parse_setup_requirements(req) for req in SETUPTOOLS_ARGS['setup_requires']] if 'scripts' in SETUPTOOLS_ARGS: pkg.tools = [os.path.split(script)[-1] for script in SETUPTOOLS_ARGS['scripts']] pkg.commands = commands return package_name, Version(version)
def bind(path, version_range=None, opts=None, parser=None): if platform_.name != 'windows': raise EnvironmentError('Only binds on windows at the moment') # find executable, determine version if opts and opts.root: bin_path = opts.root try: info = GetFileVersionInfo(os.path.join(bin_path, 'Photoshop.exe'), "\\") ms = info['FileVersionMS'] ls = info['FileVersionLS'] version = Version('{}.{}.{}.{}'.format(HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) except: raise EnvironmentError('Unknown version') else: installed_versions = [] adobe_root = r'C:\Program Files\Adobe' app_folder_prefix = 'Adobe Photoshop' for app_folder in os.listdir(adobe_root): if app_folder.startswith(app_folder_prefix): app_exe = os.path.join(adobe_root, app_folder, 'Photoshop.exe') if os.path.exists(app_exe): try: info = GetFileVersionInfo(app_exe, "\\") ms = info['FileVersionMS'] ls = info['FileVersionLS'] version = Version('{}.{}.{}.{}'.format( HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) except: raise EnvironmentError('Unknown version') installed_versions.append((app_folder, version)) if len(installed_versions) < 1: raise EnvironmentError( 'Unable to find any installed version of 3ds Max under "{}"'. format(adobe_root)) app_folder, version = sorted(installed_versions, key=lambda v: v[1])[-1] bin_path = os.path.join(adobe_root, app_folder) check_version(version, version_range) def make_root(resources_path, variant, path): import shutil shutil.copy(os.path.join(resources_path, 'Photoshop_icon.png'), os.path.join(path, 'Photoshop_icon.png')) make_root_partial = functools.partial( make_root, resource_filename(Requirement.parse('rez'), "rez/bind/resources")) with make_package("photoshop", path, make_root=make_root_partial) as pkg: pkg.version = version pkg.tools = ["photoshop"] pkg.description = 'Painting Application' pkg.authors = ['Adobe'] pkg.requires = [] pkg.nice_name = 'Photoshop' pkg.tools_info = { 'photoshop': { 'command': [ 'start', 'Photoshop', '/D', '%REZ_PHOTOSHOP_ROOT%', '/wait', '/B', 'Photoshop.exe' ], 'nice_name': 'Photoshop', 'priority': 89, 'icon': '{root}/Photoshop_icon.png', 'launch_in_prompt': False } } pkg.commands = win_commands(bin_path) pkg.variants = [system.variant] return "photoshop", version
def bind(path, version_range=None, opts=None, parser=None): if platform_.name != 'windows': raise EnvironmentError('Only binds on windows at the moment') # # find executable, determine version # if opts and opts.root: # root_path = opts.root # try: # info = GetFileVersionInfo(os.path.join(root_path, 'bin', 'deadlinecommand.exe'), "\\") # ms = info['FileVersionMS'] # ls = info['FileVersionLS'] # version = Version('{}.{}.{}.{}'.format(HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) # except: # raise EnvironmentError('Unknown version') # else: installed_versions = [] thinkbox_root = r'C:\Program Files\Thinkbox' app_folder_prefix = 'Deadline7' # previous value was 'Deadline' with no number for app_folder in os.listdir(thinkbox_root): if app_folder.startswith(app_folder_prefix): app_exe = os.path.join(thinkbox_root, app_folder, 'bin', 'deadlinecommand.exe') if os.path.exists(app_exe): try: info = GetFileVersionInfo(app_exe, "\\") ms = info['FileVersionMS'] ls = info['FileVersionLS'] version = Version('{}.{}.{}.{}'.format( HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) except: raise EnvironmentError('Unknown version') installed_versions.append((app_folder, version)) if len(installed_versions) < 1: raise EnvironmentError( 'Unable to find any installed version of Deadline under "{}"'. format(thinkbox_root)) app_folder, version = sorted(installed_versions, key=lambda v: v[1])[-1] root_path = os.path.join(thinkbox_root, app_folder, 'bin') check_version(version, version_range) def make_root(resources_path, variant, path): import shutil shutil.copy(os.path.join(resources_path, 'deadline_monitor_icon.png'), os.path.join(path, 'deadline_monitor_icon.png')) make_root_partial = functools.partial( make_root, resource_filename(Requirement.parse('rez'), "rez/bind/resources")) with make_package("deadline", path, make_root=make_root_partial) as pkg: pkg.version = version pkg.tools = ["monitor"] pkg.description = 'Render Manager' pkg.authors = ['Thinkbox'] pkg.requires = [] pkg.nice_name = 'Deadline' pkg.tools_info = { 'monitor': { 'command': ['deadlinemonitor.exe'], 'nice_name': 'Monitor', 'priority': 89, 'icon': '{root}/deadline_monitor_icon.png', 'launch_in_prompt': False } } pkg.commands = win_commands(root_path, version.major) pkg.variants = [system.variant] return "deadline", version
def bind(path, version_range=None, opts=None, parser=None): if platform_.name != 'windows': raise EnvironmentError('Only binds on windows at the moment') # find executable, determine version if opts and opts.root: bin_path = opts.root try: info = GetFileVersionInfo(os.path.join(bin_path, 'Support Files', 'AfterFX.exe'), "\\") ms = info['FileVersionMS'] ls = info['FileVersionLS'] version = Version('{}.{}.{}.{}'.format(HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) except: raise EnvironmentError('Unknown version') else: installed_versions = [] adobe_root = r'C:\Program Files\Adobe' app_folder_prefix = 'Adobe After Effects' for app_folder in os.listdir(adobe_root): if app_folder.startswith(app_folder_prefix): app_exe = os.path.join(adobe_root, app_folder, 'Support Files', 'AfterFX.exe') if os.path.exists(app_exe): try: info = GetFileVersionInfo(app_exe, "\\") ms = info['FileVersionMS'] ls = info['FileVersionLS'] version = Version('{}.{}.{}.{}'.format(HIWORD(ms), LOWORD(ms), HIWORD(ls), LOWORD(ls))) except: raise EnvironmentError('Unknown version') installed_versions.append( (app_folder, version) ) if len(installed_versions) < 1: raise EnvironmentError( 'Unable to find any installed version of After Effects under "{}"'.format( adobe_root ) ) app_folder, version = sorted(installed_versions, key=lambda v: v[1])[-1] bin_path = os.path.join(adobe_root, app_folder) check_version(version, version_range) def make_root(resources_path, variant, path): import shutil shutil.copy( os.path.join(resources_path, 'aftereffects_icon.png'), os.path.join(path, 'aftereffects_icon.png') ) make_root_partial = functools.partial(make_root, resource_filename(Requirement.parse('rez'), "rez/bind/resources")) with make_package("aftereffects", path, make_root=make_root_partial) as pkg: pkg.version = version pkg.tools = ["aftereffects"] pkg.description = 'Animation and effects application' pkg.authors = ['Adobe'] pkg.requires = [] pkg.nice_name = 'After Effects' pkg.tools_info = { 'aftereffects': { 'command': ['start', '^"AfterEffects^"', '/D', '%REZ_PHOTOSHOP_ROOT%', '/wait', '/B', 'AfterFX.exe'], 'nice_name': 'AfterEffects', 'priority': 89, 'icon': '{root}/aftereffects_icon.png', 'launch_in_prompt': False } } pkg.commands = win_commands(bin_path) pkg.variants = [system.variant] return "aftereffects", version