def parse_dict(clazz, d):
check.check_dict(d)
name = d['name']
is_folder = bool(d['isfolder'])
if is_folder:
size = None
category = None
content_type = None
content_hash = None
if 'contents' in d:
contents = [ clazz.parse_dict(item) for item in d['contents'] ]
else:
contents = None
assert 'folderid' in d
pcloud_id = d['folderid']
else:
size = d['size']
category = d['category']
content_type = d['contenttype']
content_hash = d['hash']
contents = None
assert 'fileid' in d
pcloud_id = d['fileid']
return clazz(name, pcloud_id, is_folder, size, category, content_type,
content_hash, contents, None)
def from_json_dict(clazz, o):
db = {}
check.check_dict(o)
for filename, list_item in o.items():
check.check_list(list_item)
db[filename] = source_finder_db_entry.from_list(list_item)
return clazz(db)
def __new__(clazz, filename, name, version, revision, epoch, system, level,
arch, distro, distro_version, requirements, properties, files):
check.check_string(filename)
check.check_string(name)
check.check_string(version)
revision = int(revision)
check.check_int(revision)
epoch = int(epoch)
check.check_int(epoch)
check.check_string(system)
check.check_string(level)
arch = build_arch.check_arch(arch, system, distro)
check.check_tuple(arch)
check.check_string(distro)
check.check_string(distro_version)
if check.is_string(requirements):
requirements = requirement_list.parse(requirements)
requirements = requirements or requirement_list()
check.check_requirement_list(requirements)
properties = properties or {}
check.check_dict(properties)
check.check_package_files(files)
return clazz.__bases__[0].__new__(clazz, 2, filename, name, version,
revision, epoch, system, level, arch,
distro, distro_version, requirements,
properties, files)
def from_dict(clazz, d):
check.check_dict(d)
result = clazz()
for key, value in sorted(d.items()):
check.check_string(key)
result.append(key_value(key, value))
return result
def __new__(clazz, name, flags, requires):
flags = flags or {}
requires = requires or set()
check.check_string(name)
check.check_dict(flags, key_type = check.STRING_TYPES, value_type = string_list)
check.check_set(requires, entry_type = check.STRING_TYPES)
return clazz.__bases__[0].__new__(clazz, name, flags, requires)
def resolve_values(self, substitutions, env):
check.check_dict(substitutions)
check.check_recipe_load_env_base(env)
args_definition = self.description.step_class.args_definition()
result = {}
for value in self.values:
assert value.key in args_definition
class_name = args_definition[value.key].class_name
result.update({ value.key: value.resolve(env.build_target.system, class_name) })
for name, arg_def in args_definition.items():
if name not in result:
if arg_def.default is not None:
origin = value_origin('<default>', arg_def.line_number, arg_def.default)
default_node = tree_text_parser.make_node(arg_def.default, arg_def.line_number)
value = recipe_parser_util.make_value(origin, arg_def.default, default_node, arg_def.class_name)
check.check_value_base(value)
result[name] = value.resolve([ value ], arg_def.class_name)
else:
result[name] = recipe_parser_util.value_default(arg_def.class_name)
for key, value in result.items():
if check.is_value_base(value):
value.substitutions = substitutions
return result
def __new__(clazz, name, version, revision, epoch, requirements, properties, files): check.check_string(name) check.check_string(version) check.check_int(revision) check.check_int(epoch) check.check_requirement_list(requirements) check.check_dict(properties) check.check_package_files(files) return clazz.__bases__[0].__new__(clazz, 2, name, version, revision, epoch, requirements, properties, files)
def __new__(clazz, success, message = None, failed_step = None, outputs = None):
check.check_bool(success)
if message:
check.check_string(message)
if outputs:
outputs = copy.copy(outputs)
else:
outputs = {}
check.check_dict(outputs)
return clazz.__bases__[0].__new__(clazz, success, message, failed_step, outputs)
def resolve_and_order_deps(clazz, names, descriptor_map, dependency_map): check.check_string_seq(names) check.check_dict(descriptor_map) check.check_dict(dependency_map) resolved_names = clazz.resolve_deps(dependency_map, names) resolved = [ descriptor_map[name] for name in resolved_names ] resolved_map = dict_util.filter_with_keys(dependency_map, resolved_names) build_order = clazz.build_order_flat(resolved_map) resolved = [ descriptor_map[name] for name in build_order ] return resolved
def _determine_args_definition(clazz):
defs = clazz.define_args()
if check.is_string(defs):
try:
defs = value_definition.parse_many(defs)
except RuntimeError as ex:
filename = inspect.getfile(clazz.define_args)
line_number = inspect.getsourcelines(clazz.define_args)[1]
raise RuntimeError('%s: %s:%s' % (ex.message, filename, line_number))
check.check_dict(defs)
return defs
def __new__(clazz, name, version, properties=None, requirements=None):
check.check_string(name)
if not clazz.name_is_valid(name):
raise RuntimeError('Invalid name: \"%s\"' % (name))
version = build_version.validate_version(version)
requirements = requirement_list(requirements)
check.check_requirement_list(requirements)
requirements = clazz.parse_requirements(requirements)
properties = properties or {}
check.check_dict(properties)
return clazz.__bases__[0].__new__(clazz, name, version, requirements,
properties)
def __new__(clazz, metadata, files, env_files, requirements, properties,
objects):
files = files or []
env_files = env_files or []
requirements = requirements or []
properties = properties or {}
check.check_artifact_descriptor(metadata)
check.check_temp_item_seq(files)
check.check_temp_item_seq(env_files)
check.check_requirement_list(requirements)
check.check_dict(properties)
objects = objects or {}
check.check_dict(objects)
return clazz.__bases__[0].__new__(clazz, metadata, files, env_files,
requirements, properties, objects)
def _process_main(self, location, niceness_level, timeout):
#os.nice(20)
terminated = False
self.log_i('trash process starts')
while True:
if terminated:
break
self._delete_one()
try:
payload = self._queue.get(timeout = timeout)
check.check_dict(payload)
command = payload['command']
if command == 'terminate':
self.log_i('got terminate command')
terminated = True
elif command == 'wakeup':
self.log_i('got wakeup command')
pass
except Queue.Empty as ex:
self.log_d('caught Queue.Empty exception')
pass
self.log_i('trash process ends')
return 0
def test_check_dict_and_value(self):
C.check_dict({ 'a': 5, 'b': 6 }, value_type = compat.INTEGER_TYPES)
with self.assertRaises(TypeError) as context:
C.check_dict({ 'a': 5, 6: 'b' }, value_type = compat.INTEGER_TYPES)
def test_check_dict_and_key(self):
C.check_dict({ 'a': 5, 'b': 6 }, key_type = compat.STRING_TYPES)
with self.assertRaises(TypeError) as context:
C.check_dict({ 'a': 5, 6: 'b' }, key_type = compat.STRING_TYPES)
def parse_dict(clazz, d): check.check_dict(d) assert 'email' in d assert 'password' in d assert 'root_dir' in d return clazz(d['email'], d['password'], d['root_dir'])
def test_check_dict(self):
C.check_dict({ 'a': 5 })
with self.assertRaises(TypeError) as context:
C.check_dict(True)
def values(self, values):
check.check_dict(values)
if self._values is not None:
raise ValueError('values can only be set once.')
self._values = values
def __new__(clazz, step_class, args = None):
args = args or {}
check.check_dict(args)
return clazz.__bases__[0].__new__(clazz, step_class, args)
def __init__(self, db=None):
db = db or {}
check.check_dict(db)
self._db = copy.deepcopy(db)
