def load_yaml(stream, **kwargs): """Load yaml-formatted data from a stream. Args: stream (file-like object). Returns: dict. """ # if there's an error parsing the yaml, and you pass yaml.load a string, # it will print lines of context, but will print "<string>" instead of a # filename; if you pass a stream, it will print the filename, but no lines # of context. # Get the best of both worlds, by passing it a string, then replacing # "<string>" with the filename if there's an error... content = stream.read() try: return yaml.load(content) or {} except Exception, e: if stream.name and stream.name != '<string>': for mark_name in 'context_mark', 'problem_mark': mark = getattr(e, mark_name, None) if mark is None: continue if getattr(mark, 'name') == '<string>': mark.name = stream.name raise e
def __init__(self, filepath): """Create a wrapper given its executable file.""" from rez.suite import Suite def _err(msg): raise RezSystemError("Invalid executable file %s: %s" % (filepath, msg)) with open(filepath) as f: content = f.read() try: doc = yaml.load(content, Loader=yaml.FullLoader) doc = doc["kwargs"] context_name = doc["context_name"] tool_name = doc["tool_name"] prefix_char = doc.get("prefix_char") except YAMLError as e: _err(str(e)) # check that the suite is there - a wrapper may have been moved out of # a suite's ./bin path, which renders it useless. suite_path = os.path.dirname(os.path.dirname(filepath)) try: Suite.load(suite_path) except SuiteError as e: _err(str(e)) path = os.path.join(suite_path, "contexts", "%s.rxt" % context_name) context = ResolvedContext.load(path) self._init(suite_path, context_name, context, tool_name, prefix_char)
def apply_changes(self): def _content_error(title, text): ret = QtGui.QMessageBox.warning(self, title, text, QtGui.QMessageBox.Discard, QtGui.QMessageBox.Cancel) if ret == QtGui.QMessageBox.Discard: self.discard_changes() # load new content try: txt = self.edit.toPlainText() data = yaml.load(str(txt)) except YAMLError as e: _content_error("Invalid syntax", str(e)) return # check against schema if self.schema: try: data = self.schema.validate(data) except SchemaError as e: _content_error("Settings validation failure", str(e)) return # apply to context model self.context_model.set_packages_path(data["packages_path"]) self.context_model.set_package_filter(data["package_filter"]) self._update_text()
def load_yaml(stream, **kwargs): """Load yaml-formatted data from a stream. Args: stream (file-like object). Returns: dict. """ # if there's an error parsing the yaml, and you pass yaml.load a string, # it will print lines of context, but will print "<string>" instead of a # filename; if you pass a stream, it will print the filename, but no lines # of context. # Get the best of both worlds, by passing it a string, then replacing # "<string>" with the filename if there's an error... content = stream.read() try: return yaml.load(content, Loader=yaml.FullLoader) or {} except Exception as e: if stream.name and stream.name != '<string>': for mark_name in 'context_mark', 'problem_mark': mark = getattr(e, mark_name, None) if mark is None: continue if getattr(mark, 'name') == '<string>': mark.name = stream.name raise e
def __init__(self, filepath): """Create a wrapper given its executable file.""" from rez.suite import Suite def _err(msg): raise RezSystemError("Invalid executable file %s: %s" % (filepath, msg)) with open(filepath) as f: content = f.read() try: doc = yaml.load(content) doc = doc["kwargs"] context_name = doc["context_name"] tool_name = doc["tool_name"] prefix_char = doc.get("prefix_char") except YAMLError as e: _err(str(e)) # check that the suite is there - a wrapper may have been moved out of # a suite's ./bin path, which renders it useless. suite_path = os.path.dirname(os.path.dirname(filepath)) try: Suite.load(suite_path) except SuiteError as e: _err(str(e)) path = os.path.join(suite_path, "contexts", "%s.rxt" % context_name) context = ResolvedContext.load(path) self._init(suite_path, context_name, context, tool_name, prefix_char)
def _setup_release(self): # start fresh system.clear_caches() if os.path.exists(self.install_root): shutil.rmtree(self.install_root) if os.path.exists(self.src_root): shutil.rmtree(self.src_root) shutil.copytree(self.src_path, self.src_root) self.packagefile = os.path.join(self.src_root, "package.yaml") with open(self.packagefile) as f: self.package_data = yaml.load(f.read()) # create the build system self.buildsys = create_build_system(self.src_root, verbose=True) self.assertEqual(self.buildsys.name(), "bez") # create the vcs - should error because stub file doesn't exist yet with self.assertRaises(ReleaseVCSError): create_release_vcs(self.src_root) # make the stub file self.stubfile = os.path.join(self.src_root, ".stub") with open(self.stubfile, 'w'): pass # create the vcs - should work now self.vcs = create_release_vcs(self.src_root) self.assertEqual(self.vcs.name(), "stub")
def load(self, path, as_import=False): """Load existing suite When loading suite, all contexts requests and .rxt files will be resolved and loaded. :param path: Location to save current working suite :param as_import: If True, suite could not save over to where it was loaded from. :type path: str :type as_import: bool :return: """ filepath = os.path.join(path, "suite.yaml") if not os.path.exists(filepath): raise SuiteIOError("Not a suite: %r" % path) try: with open(filepath, "rb") as f: suite_dict = yaml.load(f, Loader=yaml.FullLoader) # noqa except yaml.YAMLError as e: # noqa raise SuiteIOError("Failed loading suite: %s" % str(e)) suite = SweetSuite.from_dict(suite_dict) suite.load_path = os.path.realpath(path) self._working_suite = suite self._previous_tools = list(self.iter_tools(visible_only=True)) suite.re_resolve_rxt_contexts() suite.load_path = None if as_import else os.path.realpath(path)
def _setup_release(self): # start fresh system.clear_caches() if os.path.exists(self.install_root): shutil.rmtree(self.install_root) if os.path.exists(self.src_root): shutil.rmtree(self.src_root) shutil.copytree(self.src_path, self.src_root) self.packagefile = os.path.join(self.src_root, "package.yaml") with open(self.packagefile) as f: self.package_data = yaml.load(f.read(), Loader=yaml.FullLoader) # check build system type buildsys = create_build_system(self.src_root, verbose=True) self.assertEqual(buildsys.name(), "bez") # create the vcs - should error because stub file doesn't exist yet with self.assertRaises(ReleaseVCSError): create_release_vcs(self.src_root) # make the stub file self.stubfile = os.path.join(self.src_root, ".stub") with open(self.stubfile, 'w'): pass # create the vcs - should work now self.vcs = create_release_vcs(self.src_root) self.assertEqual(self.vcs.name(), "stub")
def command(opts, parser, extra_arg_groups=None): from rez.config import config from rez.utils.platform_ import platform_ from rez.exceptions import RezSystemError from rez.vendor import yaml from rez.vendor.yaml.error import YAMLError from rez.utils import py23 import os.path # we don't usually want warnings printed in a wrapped tool. But in cases # where we do (for debugging) we leave a backdoor - setting $REZ_QUIET=0 # will stop this warning suppression. if "REZ_QUIET" not in os.environ: config.override("quiet", True) yaml_file = os.path.abspath(opts.YAML) cli_args = opts.ARG for arg_group in (extra_arg_groups or []): cli_args.extend(arg_group) if platform_.name == "windows" and yaml_file.lower().endswith(".cmd"): with open(yaml_file) as f: content = "\n".join(f.readlines()[4:]) # strip batch script else: with open(yaml_file) as f: content = f.read() try: doc = yaml.load(content, Loader=yaml.FullLoader) except YAMLError as e: raise RezSystemError("Invalid executable file %s: %s" % (yaml_file, str(e))) func_name = doc["func_name"] nargs = doc.get("nargs", []) kwargs = doc.get("kwargs", {}) if isinstance(doc["module"], basestring): # refers to a rez module from rez.backport.importlib import import_module namespace = "rez.%s" % doc["module"] module = import_module(namespace) else: # refers to a rez plugin module from rez.plugin_managers import plugin_manager plugin_type, plugin_name = doc["module"] module = plugin_manager.get_plugin_module(plugin_type, plugin_name) target_func = getattr(module, func_name) func_args = py23.get_function_arg_names(target_func) if "_script" in func_args: kwargs["_script"] = yaml_file if "_cli_args" in func_args: kwargs["_cli_args"] = cli_args target_func(*nargs, **kwargs)
def test_1(self): """Basic release.""" # release should fail because release path does not exist self._setup_release() builder = self._create_builder() with self.assertRaises(ReleaseError): builder.release() # release should work this time os.mkdir(self.install_root) builder.release() # check a file to see the release made it filepath = os.path.join(self.install_root, "foo", "1.0", "data", "data.txt") self.assertTrue(os.path.exists(filepath)) # failed release (same version released again) builder = self._create_builder() num_variants = builder.release() self.assertEqual(num_variants, 0) # update package version and release again self.package_data["version"] = "1.1" self._write_package() builder = self._create_builder() builder.release() # change version to earlier and do failed release attempt self.package_data["version"] = "1.0.1" self._write_package() builder = self._create_builder() with self.assertRaises(ReleaseError): builder.release() # release again, this time allow not latest builder = self._create_builder(ensure_latest=False) builder.release() # change uuid and do failed release attempt self.package_data["version"] = "1.2" self.package_data["uuid"] += "_CHANGED" self._write_package() builder = self._create_builder() with self.assertRaises(ReleaseError): builder.release() # check the vcs contains the tags we expect expected_value = set(["foo-1.0", "foo-1.0.1", "foo-1.1"]) with open(self.stubfile) as f: stub_data = yaml.load(f.read()) tags = set(stub_data.get("tags", {}).keys()) self.assertEqual(tags, expected_value) # check the package install path contains the packages we expect it = iter_packages("foo", paths=[self.install_root]) qnames = set(x.qualified_name for x in it) self.assertEqual(qnames, expected_value)
def test_1(self): """Basic release.""" # release should fail because release path does not exist self._setup_release() builder = self._create_builder() with self.assertRaises(ReleaseError): builder.release() # release should work this time os.mkdir(self.install_root) builder.release() # check a file to see the release made it filepath = os.path.join(self.install_root, "foo", "1.0", "data", "data.txt") self.assertTrue(os.path.exists(filepath)) # failed release (same version released again) builder = self._create_builder() num_variants = builder.release() self.assertEqual(num_variants, 0) # update package version and release again self.package_data["version"] = "1.1" self._write_package() builder = self._create_builder() builder.release() # change version to earlier and do failed release attempt self.package_data["version"] = "1.0.1" self._write_package() builder = self._create_builder() with self.assertRaises(ReleaseError): builder.release() # release again, this time allow not latest builder = self._create_builder(ensure_latest=False) builder.release() # change uuid and do failed release attempt self.package_data["version"] = "1.2" self.package_data["uuid"] += "_CHANGED" self._write_package() builder = self._create_builder() with self.assertRaises(ReleaseError): builder.release() # check the vcs contains the tags we expect expected_value = set(["foo-1.0", "foo-1.0.1", "foo-1.1"]) with open(self.stubfile) as f: stub_data = yaml.load(f.read(), Loader=yaml.FullLoader) tags = set(stub_data.get("tags", {}).keys()) self.assertEqual(tags, expected_value) # check the package install path contains the packages we expect it = iter_packages("foo", paths=[self.install_root]) qnames = set(x.qualified_name for x in it) self.assertEqual(qnames, expected_value)
def config(self): filepath = os.path.dirname(__file__) filepath = os.path.dirname(filepath) filepath = os.path.join(filepath, "rezguiconfig") with open(filepath) as f: settings = yaml.load(f.read()) return Config(settings, organization=organisation_name, application=application_name)
def command(opts, parser, extra_arg_groups=None): from rez.config import config from rez.exceptions import RezSystemError from rez.vendor import yaml from rez.vendor.yaml.error import YAMLError import inspect import os.path # we don't usually want warnings printed in a wrapped tool. But in cases # where we do (for debugging) we leave a backdoor - setting $REZ_QUIET=0 # will stop this warning suppression. if "REZ_QUIET" not in os.environ: config.override("quiet", True) yaml_file = os.path.abspath(opts.YAML) cli_args = opts.ARG for arg_group in (extra_arg_groups or []): cli_args.append("--") cli_args.extend(arg_group) with open(yaml_file) as f: content = f.read() try: doc = yaml.load(content) except YAMLError as e: raise RezSystemError("Invalid executable file %s: %s" % (yaml_file, str(e))) func_name = doc["func_name"] nargs = doc.get("nargs", []) kwargs = doc.get("kwargs", {}) if isinstance(doc["module"], basestring): # refers to a rez module from rez.backport.importlib import import_module namespace = "rez.%s" % doc["module"] module = import_module(namespace) else: # refers to a rez plugin module from rez.plugin_managers import plugin_manager plugin_type, plugin_name = doc["module"] module = plugin_manager.get_plugin_module(plugin_type, plugin_name) target_func = getattr(module, func_name) func_args = inspect.getargspec(target_func).args if "_script" in func_args: kwargs["_script"] = yaml_file if "_cli_args" in func_args: kwargs["_cli_args"] = cli_args target_func(*nargs, **kwargs)
def _load_config_yaml(filepath): with open(filepath) as f: content = f.read() try: doc = yaml.load(content) or {} except YAMLError as e: raise ConfigurationError("Error loading configuration from %s: %s" % (filepath, str(e))) if not isinstance(doc, dict): raise ConfigurationError("Error loading configuration from %s: Expected " "dict, got %s" % (filepath, type(doc).__name__)) return doc
def _load_config_yaml(filepath): with open(filepath) as f: content = f.read() try: doc = yaml.load(content, Loader=yaml.FullLoader) or {} except YAMLError as e: raise ConfigurationError("Error loading configuration from %s: %s" % (filepath, str(e))) if not isinstance(doc, dict): raise ConfigurationError("Error loading configuration from %s: Expected " "dict, got %s" % (filepath, type(doc).__name__)) return doc
def run(): parser = argparse.ArgumentParser( \ description="Simple builtin Rez build system") parser.add_argument("TARGET", type=str, nargs='*', help="build targets") opts = parser.parse_args() # check necessary files, load info about the build for file in ("build.rxt", ".bez.yaml"): if not os.path.isfile(file): print >> sys.stderr, "no %s file found. Stop." % file sys.exit(1) with open(".bez.yaml") as f: doc = yaml.load(f.read()) source_path = doc["source_path"] buildfile = os.path.join(source_path, "rezbuild.py") if not os.path.isfile(buildfile): print >> sys.stderr, "no rezbuild.py at %s. Stop." % source_path sys.exit(1) # run rezbuild.py:build() in python subprocess. Cannot import module here # because we're in a python env configured for rez, not the build code = \ """ stream=open("%(buildfile)s") env={} exec stream in env env["build"]("%(srcpath)s","%(bldpath)s","%(instpath)s",%(targets)s) """ % dict(buildfile=buildfile, srcpath=source_path, bldpath=doc["build_path"], instpath=doc["install_path"], targets=str(opts.TARGET or None)) cli_code = textwrap.dedent(code).replace("\\", "\\\\") tmpdir_manager = TempDirs(config.tmpdir, prefix="bez_") bezfile = os.path.join(tmpdir_manager.mkdtemp(), "bezfile") with open(bezfile, "w") as fd: fd.write(cli_code) print "executing rezbuild.py..." cmd = ["python", bezfile] p = subprocess.Popen(cmd) p.wait() tmpdir_manager.clear() sys.exit(p.returncode)
def load(cls, path): if not os.path.exists(path): open(path) # raise IOError filepath = os.path.join(path, "suite.yaml") if not os.path.isfile(filepath): raise SuiteError("Not a suite: %r" % path) try: with open(filepath) as f: data = yaml.load(f.read(), Loader=yaml.FullLoader) except YAMLError as e: raise SuiteError("Failed loading suite: %s" % str(e)) s = cls.from_dict(data) s.load_path = os.path.realpath(path) return s
def load(cls, path): if not os.path.exists(path): open(path) # raise IOError filepath = os.path.join(path, "suite.yaml") if not os.path.isfile(filepath): raise SuiteError("Not a suite: %r" % path) try: with open(filepath) as f: data = yaml.load(f.read()) except YAMLError as e: raise SuiteError("Failed loading suite: %s" % str(e)) s = cls.from_dict(data) s.load_path = os.path.realpath(path) return s
def _read_stub(self): with open(os.path.join(self.vcs_root, '.stub')) as f: return yaml.load(f.read(), Loader=yaml.FullLoader) or {}
def test_1(self): """Basic release.""" # start fresh system.clear_caches() if os.path.exists(self.install_root): shutil.rmtree(self.install_root) if os.path.exists(self.src_root): shutil.rmtree(self.src_root) shutil.copytree(self.src_path, self.src_root) working_dir = self.src_root packagefile = os.path.join(working_dir, "package.yaml") with open(packagefile) as f: package_data = yaml.load(f.read()) def _write_package(): with open(packagefile, 'w') as f: dump_package_data(package_data, f, format_=FileFormat.yaml) # create the build system buildsys = create_build_system(working_dir, verbose=True) self.assertEqual(buildsys.name(), "bez") # create the vcs with self.assertRaises(ReleaseVCSError): vcs = create_release_vcs(working_dir) stubfile = os.path.join(working_dir, ".stub") with open(stubfile, 'w'): pass vcs = create_release_vcs(working_dir) self.assertEqual(vcs.name(), "stub") def _create_builder(ensure_latest=True): return create_build_process(process_type="local", working_dir=working_dir, build_system=buildsys, vcs=vcs, ensure_latest=ensure_latest, ignore_existing_tag=True, verbose=True) # release should fail because release path does not exist builder = _create_builder() with self.assertRaises(ReleaseError): builder.release() # release should work this time os.mkdir(self.install_root) builder.release() # check a file to see the release made it filepath = os.path.join(self.install_root, "foo", "1.0", "data", "data.txt") self.assertTrue(os.path.exists(filepath)) # failed release (same version released again) builder = _create_builder() num_variants = builder.release() self.assertEqual(num_variants, 0) # update package version and release again package_data["version"] = "1.1" _write_package() builder = _create_builder() builder.release() # change version to earlier and do failed release attempt package_data["version"] = "1.0.1" _write_package() builder = _create_builder() with self.assertRaises(ReleaseError): builder.release() # release again, this time allow not latest builder = _create_builder(ensure_latest=False) builder.release() # change uuid and do failed release attempt package_data["version"] = "1.2" package_data["uuid"] += "_CHANGED" _write_package() builder = _create_builder() with self.assertRaises(ReleaseError): builder.release() # check the vcs contains the tags we expect expected_value = set(["foo-1.0", "foo-1.0.1", "foo-1.1"]) with open(stubfile) as f: stub_data = yaml.load(f.read()) tags = set(stub_data.get("tags", {}).keys()) self.assertEqual(tags, expected_value) # check the package install path contains the packages we expect it = iter_packages("foo", paths=[self.install_root]) qnames = set(x.qualified_name for x in it) self.assertEqual(qnames, expected_value)
def _yaml(contents): from rez.vendor import yaml return yaml.load(contents, Loader=yaml.FullLoader)
def load_yaml(filepath): """Convenience function for loading yaml-encoded data from disk.""" with open(filepath) as f: txt = f.read() return yaml.load(txt)
def load_yaml(filepath): """Convenience function for loading yaml-encoded data from disk.""" with open(filepath) as f: txt = f.read() return yaml.load(txt, Loader=yaml.FullLoader)
def run(): parser = argparse.ArgumentParser( \ description="Simple builtin Rez build system") parser.add_argument("TARGET", type=str, nargs='*', help="build targets") opts = parser.parse_args() # check necessary files, load info about the build for file in ("build.rxt", ".bez.yaml"): if not os.path.isfile(file): print("no %s file found. Stop." % file, file=sys.stderr) sys.exit(1) with open(".bez.yaml") as f: doc = yaml.load(f.read()) source_path = doc["source_path"] buildfile = os.path.join(source_path, "rezbuild.py") if not os.path.isfile(buildfile): print("no rezbuild.py at %s. Stop." % source_path, file=sys.stderr) sys.exit(1) # run rezbuild.py:build() in python subprocess. Cannot import module here # because we're in a python env configured for rez, not the build code = \ """ env={} with open("%(buildfile)s") as stream: exec(compile(stream.read(), stream.name, 'exec'), env) buildfunc = env.get("build") if not buildfunc: import sys sys.stderr.write("Did not find function 'build' in rezbuild.py\\n") sys.exit(1) kwargs = dict(source_path="%(srcpath)s", build_path="%(bldpath)s", install_path="%(instpath)s", targets=%(targets)s, build_args=%(build_args)s) import inspect args = inspect.getargspec(buildfunc).args kwargs = dict((k, v) for k, v in kwargs.iteritems() if k in args) buildfunc(**kwargs) """ % dict(buildfile=buildfile, srcpath=source_path, bldpath=doc["build_path"], instpath=doc["install_path"], targets=str(opts.TARGET or None), build_args=str(doc.get("build_args") or [])) cli_code = textwrap.dedent(code).replace("\\", "\\\\") tmpdir_manager = TempDirs(config.tmpdir, prefix="bez_") bezfile = os.path.join(tmpdir_manager.mkdtemp(), "bezfile") with open(bezfile, "w") as fd: fd.write(cli_code) print("executing rezbuild.py...") cmd = [sys.executable, bezfile] p = subprocess.Popen(cmd) p.wait() tmpdir_manager.clear() sys.exit(p.returncode)
def _read_stub(self): with open(os.path.join(self.path, '.stub')) as f: return yaml.load(f.read()) or {}
def _read_stub(self): with open(os.path.join(self.vcs_root, '.stub')) as f: return yaml.load(f.read()) or {}