def _make_test_amt(self, recipes, publish): amt = AMT(recipes=recipes) publish = object_util.listify(publish) check.check_string_seq(publish) for p in publish: amt.publish(p) return amt
def _requires_no_resolve(self, modules): modules = object_util.listify(modules) check.check_string_seq(modules) reqs = [] for name in modules: reqs.extend(self._get_pc_file(module_name).requires) return algorithm.unique(reqs)
def resolve_deps(self, names, system, hardness, include_names): 'Resolve dependencies.' self.log_i( 'resolve_deps(names=%s, system=%s, hardness=%s, include_names=%s)' % (' '.join(names), system, ' '.join(hardness), include_names)) check.check_string_seq(names) names = object_util.listify(names) hardness = self._normalize_hardness(hardness) reqs = requirement_list() for name in names: desc = self._descriptor_map.get(name, None) if not desc: raise KeyError('Not found in packages: %s' % (name)) reqs.extend(desc.requirements.filter_by(hardness, system)) self.log_i('resolve_deps() reqs=%s' % (str(reqs.names()))) dep_map = self.dependency_map(hardness, system) result = package_descriptor_list( dependency_resolver.resolve_and_order_deps(reqs.names(), self._descriptor_map, dep_map)) self.log_i('resolve_deps() 1 result=%s' % (str(result.names()))) if include_names: result += self.descriptors(names) result.remove_dups() self.log_i('resolve_deps() 2 result=%s' % (str(result.names()))) return result
def __new__(clazz, filename, sources, headers, ldflags): check.check_string(filename) check.check_fake_package_source_seq(sources) check.check_fake_package_source_seq(headers) ldflags = ldflags or [] check.check_string_seq(ldflags) return clazz.__bases__[0].__new__(clazz, filename, sources, headers, ldflags)
def package_env_files(self, package_names): 'Return a list of env files for the given packages in the same order as packages.' check.check_string_seq(package_names) result = [] for package_name in package_names: entry = self.db.find_package(package_name) assert entry result.extend([f.filename for f in entry.files.env_files]) return result
def descriptors(self, names): check.check_string_seq(names) result = package_descriptor_list() for name in names: desc = self._descriptor_map.get(name, None) if not desc: raise ValueError('no such package found: %s' % (name)) result.append(desc) return result
def make_temp_repo(clazz, content = None): tmp_dir = temp_file.make_temp_dir() r = repo(tmp_dir, address = None) r.init() if content: check.check_string_seq(content) r.write_temp_content(content) r.add('.') r.commit('add temp repo content', '.') return r
def _resolve_requires(self, modules): modules = object_util.listify(modules) check.check_string_seq(modules) immediate_reqs = self.module_requires(module_name) immediate_req_names = [req.name for req in reqs] order = dependency_resolver.resolve_deps(self.dep_map, req_names) for mod in reqs: cflags.extend(self._single_module_cflags(mod.name)) cflags.extend(self._single_module_cflags(module_name)) return cflags
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 validate(clazz, arch, system, distro): 'Return True normalized arch if it is valid for system otherwise None.' arch = clazz.normalize(arch) check.check_string_seq(arch) build_system.check_system(system) valid_archs = clazz.VALID_ARCHS[system] for next_arch in arch: if not next_arch in valid_archs: return None return arch
def __new__(clazz, name, unixpath, pythonpath, requires): check.check_string(name) unixpath = unixpath or [] if check.is_string(unixpath): unixpath = unixpath.split(':') check.check_string_seq(unixpath) pythonpath = pythonpath or [] if check.is_string(pythonpath): pythonpath = pythonpath.split(':') check.check_string_seq(pythonpath) requires = requires or set() check.check_set(requires) return clazz.__bases__[0].__new__(clazz, name, unixpath, pythonpath, requires)
def _call_pkg_config(clazz, args, PKG_CONFIG_LIBDIR=[], PKG_CONFIG_PATH=[]): check.check_string_seq(PKG_CONFIG_PATH) cmd = [clazz._PKG_CONFIG_EXE] + object_util.listify(args) env = { 'PKG_CONFIG_DEBUG_SPEW': '1', 'PKG_CONFIG_LIBDIR': ':'.join(PKG_CONFIG_LIBDIR), 'PKG_CONFIG_PATH': ':'.join(PKG_CONFIG_PATH), # 'PATH': os_env_var('PATH').value, } for p in PKG_CONFIG_PATH: file_util.mkdir(p) #build_blurb.blurb_verbose('pkg_config', '_call_pkg_config() cmd=%s' % (str(cmd))) #print('pkg_config', '_call_pkg_config() cmd=%s; env=%s' % (str(cmd), str(env))) #print('pkg_config', '_call_pkg_config() cmd=%s' % (str(cmd))) rv = execute.execute(cmd, env=env) return rv
def transform_env(self, env, package_names): check.check_string_seq(package_names) env = env or {'PATH': os_env.DEFAULT_SYSTEM_PATH} if not 'PATH' in env: env = copy.deepcopy(env) env['PATH'] = os_env.DEFAULT_SYSTEM_PATH result = copy.deepcopy(env) os_env.update(result, self._shell_env, prepend=False) files = self.package_env_files(package_names) if not files: return result if not path.isdir(self._env_dir): return result ed = env_dir(self._env_dir, files=files) result = ed.transform_env(result) for key, value in result.items(): if key.startswith('_BES'): del result[key] return result
def test_string_seq(self): C.check_string_seq(['x']) with self.assertRaises(TypeError) as context: C.check_string_seq(6) C.check_string(6)
def __new__(clazz, directory, patterns): check.check_string(directory) if patterns: check.check_string_seq(patterns) return clazz.__bases__[0].__new__(clazz, directory, patterns)
def requires(self, modules, resolved=False): modules = object_util.listify(modules) check.check_string_seq(modules)
def filter_files(self, files): check.check_string_seq(files) return [ f for f in files if not self.should_ignore(f) ]
def requirements_from_string_list(clazz, l): check.check_string_seq(l) result = requirement_list() for n in l: result.extend(requirement_list.parse(n)) return result
def sql_encode_string_list(clazz, l, quoted=True): check.check_string_seq(l) return clazz.sql_encode_string(json_util.to_json(l), quoted=quoted)
def join(clazz, arch, delimiter=','): 'Join arch parts by delimiter.' check.check_string_seq(arch) arch = [a.strip() for a in arch] return delimiter.join(arch)
def _parse_requirements(clazz, l): check.check_string_seq(l) reqs = requirement_list() for n in l: reqs.extend(requirement_list.parse(n)) return reqs