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 _load_config_py(filepath):
reserved = dict(
# Standard Python module variables
# Made available from within the module,
# and later excluded from the `Config` class
__name__=os.path.splitext(os.path.basename(filepath))[0],
__file__=filepath,
rez_version=__version__,
ModifyList=ModifyList,
DelayLoad=DelayLoad)
g = reserved.copy()
result = {}
with open(filepath) as f:
try:
code = compile(f.read(), filepath, 'exec')
exec(code, g)
except Exception as e:
raise ConfigurationError(
"Error loading configuration from %s: %s" % (filepath, str(e)))
for k, v in g.items():
if k != '__builtins__' \
and not ismodule(v) \
and k not in reserved:
result[k] = v
return result
def __getattr__(self, attr):
if attr in self.__dict__:
return self.__dict__[attr]
data = self.__dict__['_data']
from rez.plugin_managers import plugin_manager
if attr in plugin_manager.get_plugin_types():
# get plugin config data, and apply overrides
plugin_type = attr
config_data = plugin_manager.get_plugin_config_data(plugin_type)
d = copy.deepcopy(config_data)
deep_update(d, data.get(plugin_type, {}))
# validate
schema = plugin_manager.get_plugin_config_schema(plugin_type)
try:
d = schema.validate(d)
except SchemaError as e:
raise ConfigurationError(
"Error in Rez configuration under plugins.%s: %s" %
(plugin_type, str(e)))
elif attr in data:
d = data[attr]
else:
raise AttributeError(
"No such configuration setting: 'plugins.%s'" % attr)
d_ = convert_dicts(d, RO_AttrDictWrapper)
self.__dict__[attr] = d_
return d_
def _parse_env_var(self, value):
items = value.split(",")
try:
return dict([item.split(":") for item in items])
except ValueError:
raise ConfigurationError(
"expected dict string in form 'k1:v1,k2:v2,...kN:vN': %s" %
value)
def validate(self, data):
try:
data = self._validate(data)
data = self.schema.validate(data)
data = expand_system_vars(data)
except SchemaError as e:
raise ConfigurationError("Misconfigured setting '%s': %s" %
(self.key, str(e)))
return data
def _parse_env_var(self, value):
value = value.lower()
if value in self.true_words:
return True
elif value in self.false_words:
return False
else:
raise ConfigurationError(
"Expected $%s to be one of: %s" %
(self._env_var_name, ", ".join(self.all_words)))
def parse_rule(cls, txt):
"""Parse a rule from a string.
See rezconfig.package_filter for an overview of valid strings.
Args:
txt (str): String to parse.
Returns:
`Rule` instance.
"""
types = {
"glob": GlobRule,
"regex": RegexRule,
"range": RangeRule,
"before": TimestampRule,
"after": TimestampRule
}
# parse form 'x(y)' into x, y
label, txt = Rule._parse_label(txt)
if label is None:
if '*' in txt:
label = "glob"
else:
label = "range"
elif label not in types:
raise ConfigurationError(
"'%s' is not a valid package filter type" % label)
rule_cls = types[label]
txt_ = "%s(%s)" % (label, txt)
try:
rule = rule_cls._parse(txt_)
except Exception as e:
raise ConfigurationError(
"Error parsing package filter '%s': %s: %s" %
(txt_, e.__class__.__name__, str(e)))
return rule
def _load_config_py(filepath):
from rez.vendor.six.six import exec_
globs = dict(rez_version=__version__)
result = {}
with open(filepath) as f:
try:
code = compile(f.read(), filepath, 'exec')
exec_(code, _globs_=globs)
except Exception, e:
raise ConfigurationError(
"Error loading configuration from %s: %s" % (filepath, str(e)))
def file_lock_dir(self):
dirname = self.settings.file_lock_dir
if not dirname:
return None
path = os.path.join(self.location, dirname)
path_ = os.path.dirname(path)
if os.path.realpath(path_) != os.path.realpath(self.location):
raise ConfigurationError(
"filesystem package repository setting 'file_lock_dir' must be "
"a single relative directory such as '.lock'")
return os.path.basename(path)
def file_lock_dir(self):
dirname = _settings.file_lock_dir
if not dirname:
return None
# sanity check
if os.path.isabs(dirname) or os.path.basename(dirname) != dirname:
raise ConfigurationError(
"filesystem package repository setting 'file_lock_dir' must be "
"a single relative directory such as '.lock'")
# fall back to location path if lock dir doesn't exist.
path = os.path.join(self.location, dirname)
if not os.path.exists(path):
return None
return dirname
def _load_config_py(filepath):
from rez.vendor.six.six import exec_
reserved = dict(
# Standard Python module variables
# Made available from within the module,
# and later excluded from the `Config` class
__name__=os.path.splitext(os.path.basename(filepath))[0],
__file__=filepath,
rez_version=__version__,
ModifyList=ModifyList)
globs = reserved.copy()
result = {}
with open(filepath) as f:
try:
code = compile(f.read(), filepath, 'exec')
exec_(code, _globs_=globs)
except Exception, e:
raise ConfigurationError(
"Error loading configuration from %s: %s" % (filepath, str(e)))
def _parse_env_var(self, value):
items = value.split(",")
result = {}
for item in items:
if ':' not in item:
raise ConfigurationError(
"Expected dict string in form 'k1:v1,k2:v2,...kN:vN': %s" %
value)
k, v = item.split(':', 1)
try:
v = int(v)
except ValueError:
try:
v = float(v)
except ValueError:
pass
result[k] = v
return result
def _validate(self, data):
# overridden settings take precedence. Note that `data` has already
# taken override into account at this point
if self.key in self.config.overrides:
return data
if not self.config.locked:
# next, env-var
value = os.getenv(self._env_var_name)
if value is not None:
return self._parse_env_var(value)
# next, JSON-encoded env-var
varname = self._env_var_name + "_JSON"
value = os.getenv(varname)
if value is not None:
from rez.utils import json
try:
return json.loads(value)
except ValueError:
raise ConfigurationError(
"Expected $%s to be JSON-encoded string." % varname
)
# next, data unchanged
if data is not None:
return data
# some settings have a programmatic default
attr = "_get_%s" % self.key
if hasattr(self.config, attr):
return getattr(self.config, attr)()
# setting is None
return None
def _parse_env_var(self, value):
try:
return float(value)
except ValueError:
raise ConfigurationError("Expected %s to be a float" %
self._env_var_name)
def _parse_env_var(self, value):
try:
return int(value)
except ValueError:
raise ConfigurationError("expected %s to be an integer" %
self._env_var_name)
"""
Abstraction for PyQt/PySide import.
"""
import sys
from rez.config import config
from rez.exceptions import RezGuiQTImportError
from rez.utils.lint_helper import used
USE_PYSIDE = None
if config.use_pyside:
if config.use_pyqt:
from rez.exceptions import ConfigurationError
raise ConfigurationError(
"'use_pyside' and 'use_pyqt' are both enabled")
USE_PYSIDE = True
elif config.use_pyqt:
USE_PYSIDE = False
if USE_PYSIDE is None:
if 'PyQt4' in sys.modules:
USE_PYSIDE = False
elif 'PySide' in sys.modules:
USE_PYSIDE = True
else:
try:
import PyQt4
used(PyQt4)
USE_PYSIDE = False
except ImportError:
try:
import PySide