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)