def _load_export_conanfile(conanfile_path, output, name, version): conanfile = load_conanfile_class(conanfile_path) for field in ["url", "license", "description"]: field_value = getattr(conanfile, field, None) if not field_value: output.warn("Conanfile doesn't have '%s'.\n" "It is recommended to add it as attribute" % field) try: # Exports is the only object field, we need to do this, because conan export needs it conanfile.exports = create_exports(conanfile) conanfile.exports_sources = create_exports_sources(conanfile) except Exception as e: # re-raise with file name raise ConanException("%s: %s" % (conanfile_path, str(e))) # check name and version were specified if not conanfile.name: if name: conanfile.name = name else: raise ConanException("conanfile didn't specify name") elif name and name != conanfile.name: raise ConanException("Package recipe exported with name %s!=%s" % (name, conanfile.name)) if not conanfile.version: if version: conanfile.version = version else: raise ConanException("conanfile didn't specify version") elif version and version != conanfile.version: raise ConanException("Package recipe exported with version %s!=%s" % (version, conanfile.version)) return conanfile
def load_export_conanfile(conanfile_path, output): conanfile = load_conanfile_class(conanfile_path) for field in ["url", "license", "description"]: field_value = getattr(conanfile, field, None) if not field_value: output.warn("Conanfile doesn't have '%s'.\n" "It is recommended to add it as attribute" % field) if getattr(conanfile, "conan_info", None): output.warn( "conan_info() method is deprecated, use package_id() instead") try: # Exports is the only object field, we need to do this, because conan export needs it conanfile.exports = create_exports(conanfile) conanfile.exports_sources = create_exports_sources(conanfile) except Exception as e: # re-raise with file name raise ConanException("%s: %s" % (conanfile_path, str(e))) # check name and version were specified if not hasattr(conanfile, "name") or not conanfile.name: raise ConanException("conanfile didn't specify name") if not hasattr(conanfile, "version") or not conanfile.version: raise ConanException("conanfile didn't specify version") return conanfile
def load_export_conanfile(conanfile_path, output): conanfile = load_conanfile_class(conanfile_path) for field in ["url", "license", "description"]: field_value = getattr(conanfile, field, None) if not field_value: output.warn("Conanfile doesn't have '%s'.\n" "It is recommended to add it as attribute" % field) if getattr(conanfile, "conan_info", None): output.warn("conan_info() method is deprecated, use package_id() instead") try: # Exports is the only object field, we need to do this, because conan export needs it conanfile.exports = create_exports(conanfile) conanfile.exports_sources = create_exports_sources(conanfile) except Exception as e: # re-raise with file name raise ConanException("%s: %s" % (conanfile_path, str(e))) # check name and version were specified if not hasattr(conanfile, "name") or not conanfile.name: raise ConanException("conanfile didn't specify name") if not hasattr(conanfile, "version") or not conanfile.version: raise ConanException("conanfile didn't specify version") return conanfile
def load_cf_class(path, conan_api): client_version = get_client_version() client_version = Version(client_version) if client_version < Version("1.7.0"): from conans.client.loader_parse import load_conanfile_class return load_conanfile_class(path) elif client_version < Version("1.14.0"): return conan_api._loader.load_class(path) elif client_version < Version("1.15.0"): remotes = conan_api._cache.registry.remotes.list for remote in remotes: conan_api.python_requires.enable_remotes(remote_name=remote) return conan_api._loader.load_class(path) elif client_version < Version("1.16.0"): remotes = conan_api._cache.registry.load_remotes() conan_api.python_requires.enable_remotes(remotes=remotes) return conan_api._loader.load_class(path) elif client_version < Version("1.18.0"): remotes = conan_api._cache.registry.load_remotes() conan_api._python_requires.enable_remotes(remotes=remotes) return conan_api._loader.load_class(path) else: if not conan_api.app: conan_api.create_app() remotes = conan_api.app.cache.registry.load_remotes() conan_api.app.python_requires.enable_remotes(remotes=remotes) conan_api.app.pyreq_loader.enable_remotes(remotes=remotes) if client_version < Version("1.20.0"): return conan_api.app.loader.load_class(path) elif client_version < Version("1.21.0"): return conan_api.app.loader.load_basic(path) else: return conan_api.app.loader.load_named(path, None, None, None, None)
def confirm(files): conanfile = load_conanfile_class(os.path.join(__dir__, 'conanfile.py')) m.info(''' version: %s bumped. the following files has been modified, please verify. ''' % conanfile.version) res = prompt('commit this change(yes) or rollback (no)?', ['yes', 'no']) if res == 'yes': call('git commit -a -m "bumps to version %s"' % conanfile.version) call('git tag v{0} -m "bumps to version {0}"'.format( conanfile.version)) m.success('version %s has been bumped.' % conanfile.version) m.info(''' Now we will push the commit to remote ''') os.system('git push') m.info(''' Now we will push the commit and tags to remote ''') os.system('git push --tags') m.warn('DO NOT forget change the branch to dev version.') else: for filename in files: call('git checkout -- %s' % filename) m.warn('version bump canceled, all changed file reverted.')
def copy(self, reference, package_ids, username, channel, force=False): """ Copy or move conanfile (exported) and packages to another user and or channel @param reference: ConanFileReference containing the packages to be moved @param package_ids: list of ids or [] for all list @param username: Destination username @param channel: Destination channel @param remote: install only from that remote """ # It is necessary to make sure the sources are complete before proceeding remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, None) # Now we can actually copy conan_file_path = self._client_cache.conanfile(reference) conanfile = load_conanfile_class(conan_file_path) remote_proxy.complete_recipe_sources(reference, short_paths=conanfile.short_paths) copier = PackageCopier(self._client_cache, self._user_io, conanfile.short_paths) if not package_ids: packages = self._client_cache.packages(reference) if os.path.exists(packages): package_ids = os.listdir(packages) else: package_ids = [] copier.copy(reference, package_ids, username, channel, force)
def package(self, reference, package_id): # Package paths conan_file_path = self._client_cache.conanfile(reference) if not os.path.exists(conan_file_path): raise ConanException("Package recipe '%s' does not exist" % str(reference)) conanfile = load_conanfile_class(conan_file_path) if hasattr(conanfile, "build_id"): raise ConanException( "package command does not support recipes with 'build_id'\n" "To repackage them use 'conan install'") if not package_id: packages = [ PackageReference(reference, packid) for packid in self._client_cache.conan_builds(reference) ] if not packages: raise NotFoundException( "%s: Package recipe has not been built locally\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % str(reference)) else: packages = [PackageReference(reference, package_id)] package_source_folder = self._client_cache.source( reference, conanfile.short_paths) for package_reference in packages: build_folder = self._client_cache.build(package_reference, short_paths=None) if not os.path.exists(build_folder): raise NotFoundException( "%s: Package binary '%s' folder doesn't exist\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % (str(reference), package_reference.package_id)) # The package already exist, we can use short_paths if they were defined package_folder = self._client_cache.package(package_reference, short_paths=None) # Will read current conaninfo with specified options and load conanfile with them output = ScopedOutput(str(reference), self._user_io.out) output.info("Re-packaging %s" % package_reference.package_id) conanfile = load_consumer_conanfile(conan_file_path, build_folder, self._client_cache.settings, self._runner, output, reference=reference) rmdir(package_folder) if getattr(conanfile, 'no_copy_source', False): source_folder = package_source_folder else: source_folder = build_folder with environment_append(conanfile.env): packager.create_package(conanfile, source_folder, build_folder, package_folder, output)
def _prepare_sources(client_cache, user_io, remote_manager, reference): remote_proxy = ConanProxy(client_cache, user_io, remote_manager, None) conan_file_path = client_cache.conanfile(reference) conanfile = load_conanfile_class(conan_file_path) remote_proxy.complete_recipe_sources(conanfile, reference, short_paths=conanfile.short_paths) return conanfile.short_paths
def export_pkg(self, path, name, channel, source_folder=None, build_folder=None, install_folder=None, profile_name=None, settings=None, options=None, env=None, force=False, user=None, version=None): settings = settings or [] options = options or [] env = env or [] cwd = os.getcwd() # Checks that info files exists if the install folder is specified self._validate_can_read_infos(install_folder, cwd) path = self._abs_relative_to(path, cwd) build_folder = self._abs_relative_to(build_folder, cwd, default=cwd) install_folder = self._abs_relative_to(install_folder, cwd, default=build_folder) source_folder = self._abs_relative_to(source_folder, cwd, default=build_folder) # Checks that no both settings and info files are specified self._validate_one_settings_source(install_folder, profile_name, settings, options, env) profile = self._get_profile(profile_name, settings, options, env, cwd, install_folder) conanfile_abs_path = self._get_conanfile_path(path, "conanfile.py") conanfile = load_conanfile_class(conanfile_abs_path) if (name and conanfile.name and conanfile.name != name) or \ (version and conanfile.version and conanfile.version != version): raise ConanException( "Specified name/version doesn't match with the " "name/version in the conanfile") self._manager.export(user, channel, path, name=name, version=version) if not (name and version): name = conanfile.name version = conanfile.version reference = ConanFileReference(name, version, user, channel) self._manager.export_pkg(reference, source_folder=source_folder, build_folder=build_folder, install_folder=install_folder, profile=profile, force=force)
def export_pkg(self, conanfile_path, name, channel, source_folder=None, build_folder=None, package_folder=None, install_folder=None, profile_name=None, settings=None, options=None, env=None, force=False, user=None, version=None, cwd=None): settings = settings or [] options = options or [] env = env or [] cwd = cwd or get_cwd() # Checks that info files exists if the install folder is specified if install_folder and not existing_info_files(_make_abs_path(install_folder, cwd)): raise ConanException("The specified install folder doesn't contain '%s' and '%s' " "files" % (CONANINFO, BUILD_INFO)) conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True) if package_folder: if build_folder or source_folder: raise ConanException("package folder definition incompatible with build and source folders") package_folder = _make_abs_path(package_folder, cwd) build_folder = _make_abs_path(build_folder, cwd) install_folder = _make_abs_path(install_folder, cwd, default=build_folder) source_folder = _make_abs_path(source_folder, cwd, default=os.path.dirname(conanfile_path)) # Checks that no both settings and info files are specified if install_folder and existing_info_files(install_folder) and \ (profile_name or settings or options or env): raise ConanException("%s and %s are found, at '%s' folder, so specifying profile, " "settings, options or env is not allowed" % (CONANINFO, BUILD_INFO, install_folder)) infos_present = existing_info_files(install_folder) if not infos_present: profile = profile_from_args(profile_name, settings, options, env=env, cwd=cwd, client_cache=self._client_cache) else: profile = read_conaninfo_profile(install_folder) conanfile = load_conanfile_class(conanfile_path) if (name and conanfile.name and conanfile.name != name) or \ (version and conanfile.version and conanfile.version != version): raise ConanException("Specified name/version doesn't match with the " "name/version in the conanfile") cmd_export(conanfile_path, name, version, user, channel, False, self._user_io.out, self._client_cache) if not (name and version): name = conanfile.name version = conanfile.version reference = ConanFileReference(name, version, user, channel) recorder = ActionRecorder() manager = self._init_manager(recorder) manager.export_pkg(reference, source_folder=source_folder, build_folder=build_folder, package_folder=package_folder, install_folder=install_folder, profile=profile, force=force)
def _get_recipe(self, conan_reference): output = ScopedOutput(str(conan_reference), self._out) # check if it is in disk conanfile_path = self._client_cache.conanfile(conan_reference) if os.path.exists(conanfile_path): log_recipe_got_from_local_cache(conan_reference) if self._check_updates: ret = self.update_available(conan_reference) if ret != 0: # Found and not equal remote, ref_remote = self._get_remote(conan_reference) if ret == 1: if not self._update: if remote != ref_remote: # Forced new remote output.warn( "There is a new conanfile in '%s' remote. " "Execute 'install -u -r %s' to update it." % (remote.name, remote.name)) else: output.warn( "There is a new conanfile in '%s' remote. " "Execute 'install -u' to update it." % remote.name) output.warn("Refused to install!") else: export_path = self._client_cache.export( conan_reference) DiskRemover( self._client_cache).remove(conan_reference) output.info("Retrieving from remote '%s'..." % remote.name) self._remote_manager.get_recipe( conan_reference, export_path, remote) output.info("Updated!") elif ret == -1: if not self._update: output.info("Current conanfile is newer " "than %s's one" % remote.name) else: output.error( "Current conanfile is newer than %s's one. " "Run 'conan remove %s' and run install again " "to replace it." % (remote.name, conan_reference)) else: self._retrieve_recipe(conan_reference, output) if self._manifest_manager: # Just make sure that the recipe sources are there to check conanfile = load_conanfile_class(conanfile_path) self.get_recipe_sources(conan_reference, conanfile.short_paths) remote = self._registry.get_ref(conan_reference) self._manifest_manager.check_recipe(conan_reference, remote) return conanfile_path
def check_reference(self, conan_reference): try: conanfile_path = self._paths.conanfile(conan_reference) conan_file = load_conanfile_class(conanfile_path) except NotFoundException: raise NotFoundException("There is no local conanfile exported as %s" % str(conan_reference)) # Can't use build_policy_always here because it's not loaded (only load_class) if conan_file.build_policy == "always": raise ConanException("Conanfile has build_policy='always', " "no packages can be uploaded")
def build(): n = get_build_number() conanfile = load_conanfile_class(os.path.join(__dir__, 'conanfile.py')) version = conanfile.version CONAN_STABLE_CHANNEL = None if n == 0: CONAN_CHANNEL = 'stable' CONAN_UPLOAD_ONLY_WHEN_STABLE = True else: version = '%s.%d' % (version, n) CONAN_CHANNEL = 'testing' CONAN_UPLOAD_ONLY_WHEN_STABLE = False CONAN_STABLE_CHANNEL = 'testing' update_version(version) CONAN_UPLOAD = 'https://api.bintray.com/conan/%s/%s' % (CONAN_USERNAME, CONAN_CHANNEL) builder = ConanMultiPackager( channel=CONAN_CHANNEL, upload_only_when_stable=CONAN_UPLOAD_ONLY_WHEN_STABLE, upload=CONAN_UPLOAD, username=CONAN_USERNAME, stable_channel=CONAN_STABLE_CHANNEL) builder.add_common_builds() builds = [] for settings, options, env_vars, build_requires, reference in builder.items: # dynamic only if not options["libwebstreamer:shared"]: continue # release only if settings["build_type"] == "Debug": continue # Visual Sutido 2017 only if platform.system() == "Windows": if settings["compiler"] == "Visual Studio": if settings["compiler.version"] == '14': builds.append( [settings, options, env_vars, build_requires]) elif platform.system() == "Linux": if settings["compiler"] == "gcc": if settings["compiler.version"] == '4.9' and settings[ "arch"] == 'x86_64': builds.append([ settings, options, { 'DEPENDENT_BINTRAY_REPO': DEPENDENT_BINTRAY_REPO }, build_requires ]) builder.builds = builds builder.run()
def check_reference(self, conan_reference): try: conanfile_path = self._paths.conanfile(conan_reference) conan_file = load_conanfile_class(conanfile_path) except NotFoundException: raise NotFoundException("There is no local conanfile exported as %s" % str(conan_reference)) # Can't use build_policy_always here because it's not loaded (only load_class) if conan_file.build_policy == "always": raise ConanException("Conanfile has build_policy='always', " "no packages can be uploaded")
def download_binaries(reference, package_ids, client_cache, remote_manager, remote, output, recorder): conanfile_path = client_cache.conanfile(reference) if not os.path.exists(conanfile_path): raise Exception("Download recipe first") conanfile = load_conanfile_class(conanfile_path) short_paths = conanfile.short_paths for package_id in package_ids: package_ref = PackageReference(reference, package_id) package_folder = client_cache.package(package_ref, short_paths=short_paths) output.info("Downloading %s" % str(package_ref)) remote_manager.get_package(package_ref, package_folder, remote, output, recorder)
def _get_recipe(self, conan_reference, check_updates, update): output = ScopedOutput(str(conan_reference), self._out) check_updates = check_updates or update # check if it is in disk conanfile_path = self._client_cache.conanfile(conan_reference) if os.path.exists(conanfile_path): if check_updates: ret = self.update_available(conan_reference) if ret != 0: # Found and not equal remote, ref_remote = self._get_remote(conan_reference) if ret == 1: if not update: if remote != ref_remote: # Forced new remote output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u -r %s' to update it." % (remote.name, remote.name)) else: output.warn("There is a new conanfile in '%s' remote. " "Execute 'install -u' to update it." % remote.name) output.warn("Refused to install!") else: DiskRemover(self._client_cache).remove(conan_reference) output.info("Retrieving from remote '%s'..." % remote.name) self._remote_manager.get_recipe(conan_reference, remote) output.info("Updated!") elif ret == -1: if not update: output.info("Current conanfile is newer than %s's one" % remote.name) else: output.error("Current conanfile is newer than %s's one. " "Run 'conan remove %s' and run install again " "to replace it." % (remote.name, conan_reference)) log_recipe_got_from_local_cache(conan_reference) self._recorder.recipe_fetched_from_cache(conan_reference) else: self._retrieve_recipe(conan_reference, output) if self._manifest_manager: # Just make sure that the recipe sources are there to check conanfile = load_conanfile_class(conanfile_path) complete_recipe_sources(self._remote_manager, self._client_cache, self._registry, conanfile, conan_reference) remote = self._registry.get_ref(conan_reference) self._manifest_manager.check_recipe(conan_reference, remote) return conanfile_path
def add_common_builds(self, shared_option_name=None, pure_c=True, dll_with_static_runtime=False, reference=None): if shared_option_name is None: if os.path.exists("conanfile.py"): conanfile = load_conanfile_class("./conanfile.py") if hasattr(conanfile, "options") and "shared" in conanfile.options: shared_option_name = "%s:shared" % self.reference.name tmp = self.build_generator.get_builds(pure_c, shared_option_name, dll_with_static_runtime, reference or self.reference) self._builds.extend(tmp)
def download_packages(self, reference, package_ids): assert(isinstance(package_ids, list)) remote, _ = self._get_remote(reference) export_path = self._client_cache.export(reference) self._remote_manager.get_recipe(reference, export_path, remote) conanfile_path = self._client_cache.conanfile(reference) conanfile = load_conanfile_class(conanfile_path) short_paths = conanfile.short_paths self._registry.set_ref(reference, remote) output = ScopedOutput(str(reference), self._out) for package_id in package_ids: package_ref = PackageReference(reference, package_id) package_folder = self._client_cache.package(package_ref, short_paths=short_paths) self._retrieve_remote_package(package_ref, package_folder, output, remote)
def download_packages(self, reference, package_ids): assert(isinstance(package_ids, list)) remote, _ = self._get_remote(reference) export_path = self._client_cache.export(reference) self._remote_manager.get_recipe(reference, export_path, remote) conanfile_path = self._client_cache.conanfile(reference) conanfile = load_conanfile_class(conanfile_path) short_paths = conanfile.short_paths self._registry.set_ref(reference, remote) output = ScopedOutput(str(reference), self._out) for package_id in package_ids: package_ref = PackageReference(reference, package_id) package_folder = self._client_cache.package(package_ref, short_paths=short_paths) self._out.info("Downloading %s" % str(package_ref)) self._retrieve_remote_package(package_ref, package_folder, output, remote)
def _upload_recipe(self, conan_reference, retry, retry_wait, skip_upload, no_overwrite, remote): conan_file_path = self._client_cache.conanfile(conan_reference) current_remote = self._registry.get_ref(conan_reference) if remote != current_remote: conanfile = load_conanfile_class(conan_file_path) complete_recipe_sources(self._remote_manager, self._client_cache, self._registry, conanfile, conan_reference) ignore_deleted_file = None else: ignore_deleted_file = EXPORT_SOURCES_TGZ_NAME result = self._remote_manager.upload_recipe(conan_reference, remote, retry, retry_wait, ignore_deleted_file=ignore_deleted_file, skip_upload=skip_upload, no_overwrite=no_overwrite) return result
def load_conan(self, conanfile_path, output, consumer=False, reference=None): """ loads a ConanFile object from the given file """ result = load_conanfile_class(conanfile_path) try: # Prepare the settings for the loaded conanfile # Mixing the global settings with the specified for that name if exist tmp_settings = self._settings.copy() if self._package_settings and result.name in self._package_settings: # Update the values, keeping old ones (confusing assign) values_tuple = self._package_settings[result.name] tmp_settings.values = Values.from_list(values_tuple) if reference: result.name = reference.name result.version = reference.version user, channel = reference.user, reference.channel else: user, channel = None, None # Instance the conanfile result = result(output, self._runner, tmp_settings, os.path.dirname(conanfile_path), user, channel) # Assign environment result._env_values.update(self._env_values) if consumer: self._user_options.descope_options(result.name) result.options.initialize_upstream(self._user_options) self._user_options.clear_unscoped_options() # If this is the consumer project, it has no name result.scope = self._scopes.package_scope() else: result.scope = self._scopes.package_scope(result.name) result.in_local_cache = True if consumer or (self.dev_reference and self.dev_reference == reference): result.develop = True return result except Exception as e: # re-raise with file name raise ConanException("%s: %s" % (conanfile_path, str(e)))
def __init__(self): conanfile_path = os.path.join(os.getcwd(), "conanfile.py") self.conanfile = load_conanfile_class(conanfile_path) self.options = self.conanfile.options self.default_options = {} default_options = self.conanfile.default_options for dopt in default_options: key, value = dopt.split("=") self.default_options[key] = value self.user = None self.channel = None self.custom_content = 'This is additional text to insert into the README.'
def hint(): conanfile = load_conanfile_class(os.path.join(__dir__,'conanfile.py')) m.writeln('') m.writeln('WE WILL BUMP THIS REPO TO NEW VERSION AND TAG IT.', Color.BRIGHT_MAGENTA) m.writeln('current version : %s\n'%conanfile.version) m.info('[major] => %s'%semver.inc(conanfile.version,'major',loose=True)) m.info('[minor] => %s'%semver.inc(conanfile.version,'minor',loose=True)) m.info('[patch] => %s'%semver.inc(conanfile.version,'patch',loose=True)) m.info('[cancel] cancel the version bump\n') res = prompt('which version to bump ?',['major','minor','patch','cancel']) if res == 'cancel': m.warn('you have cancel this version bumping.') return None return semver.inc(conanfile.version,res,loose=True)
def package(self, reference, package_id): # Package paths conan_file_path = self._client_cache.conanfile(reference) if not os.path.exists(conan_file_path): raise ConanException("Package recipe '%s' does not exist" % str(reference)) conanfile = load_conanfile_class(conan_file_path) if hasattr(conanfile, "build_id"): raise ConanException("package command does not support recipes with 'build_id'\n" "To repackage them use 'conan install'") if not package_id: packages = [PackageReference(reference, packid) for packid in self._client_cache.conan_builds(reference)] if not packages: raise NotFoundException("%s: Package recipe has not been built locally\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % str(reference)) else: packages = [PackageReference(reference, package_id)] package_source_folder = self._client_cache.source(reference, conanfile.short_paths) for package_reference in packages: build_folder = self._client_cache.build(package_reference, short_paths=None) if not os.path.exists(build_folder): raise NotFoundException("%s: Package binary '%s' folder doesn't exist\n" "Please read the 'conan package' command help\n" "Use 'conan install' or 'conan test_package' to build and " "create binaries" % (str(reference), package_reference.package_id)) # The package already exist, we can use short_paths if they were defined package_folder = self._client_cache.package(package_reference, short_paths=None) # Will read current conaninfo with specified options and load conanfile with them output = ScopedOutput(str(reference), self._user_io.out) output.info("Re-packaging %s" % package_reference.package_id) conanfile = load_consumer_conanfile(conan_file_path, build_folder, self._client_cache.settings, self._runner, output, reference) rmdir(package_folder) if getattr(conanfile, 'no_copy_source', False): source_folder = package_source_folder else: source_folder = build_folder with environment_append(conanfile.env): packager.create_package(conanfile, source_folder, build_folder, package_folder, output)
def download_packages(self, reference, package_ids): assert(isinstance(package_ids, list)) remote, _ = self._get_remote(reference) conanfile_path = self._client_cache.conanfile(reference) if not os.path.exists(conanfile_path): raise Exception("Download recipe first") conanfile = load_conanfile_class(conanfile_path) # FIXME: This is a hack to provide a info object in case it fails and raise_package_not_found_error doesnt fail conanfile.info = ConanInfo.loads("") short_paths = conanfile.short_paths self._registry.set_ref(reference, remote) output = ScopedOutput(str(reference), self._out) for package_id in package_ids: package_ref = PackageReference(reference, package_id) package_folder = self._client_cache.package(package_ref, short_paths=short_paths) self._out.info("Downloading %s" % str(package_ref)) self._remote_manager.get_package(conanfile, package_ref, package_folder, remote, output, self._recorder)
def upload_recipe(self, conan_reference, retry, retry_wait, skip_upload): """ upload to defined remote in (-r=remote), to current remote or to default remote, in that order. If the remote is not set, set it """ conan_file_path = self._client_cache.conanfile(conan_reference) conanfile = load_conanfile_class(conan_file_path) ignore_deleted_file = self.complete_recipe_sources(conanfile, conan_reference, force_complete=False, short_paths=conanfile.short_paths) remote, ref_remote = self._get_remote(conan_reference) result = self._remote_manager.upload_recipe(conan_reference, remote, retry, retry_wait, ignore_deleted_file=ignore_deleted_file, skip_upload=skip_upload) if not ref_remote and not skip_upload: self._registry.set_ref(conan_reference, remote) return result
def download(self, reference, package_ids, remote, recipe): """ Download conanfile and specified packages to local repository @param reference: ConanFileReference @param package_ids: Package ids or empty for download all @param remote: install only from that remote @param only_recipe: download only the recipe """ assert (isinstance(reference, ConanFileReference)) remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote, recorder=self._recorder) remote, _ = remote_proxy._get_remote() package = self._remote_manager.search_recipes(remote, reference, None) if not package: # Search the reference first, and raise if it doesn't exist raise ConanException("'%s' not found in remote" % str(reference)) # First of all download package recipe remote_proxy.get_recipe(reference) if recipe: return # Download the sources too, don't be lazy conan_file_path = self._client_cache.conanfile(reference) conanfile = load_conanfile_class(conan_file_path) remote_proxy.complete_recipe_sources(conanfile, reference, short_paths=conanfile.short_paths) if package_ids: remote_proxy.download_packages(reference, package_ids) else: self._user_io.out.info("Getting the complete package list " "from '%s'..." % str(reference)) packages_props = self._remote_manager.search_packages( remote, reference, None) if not packages_props: output = ScopedOutput(str(reference), self._user_io.out) output.warn("No remote binary packages found in remote") else: remote_proxy.download_packages(reference, list(packages_props.keys()))
def inherit_short_paths_test(self): loader = ConanFileLoader(None, Settings(), Profile()) tmp_dir = temp_folder() conanfile_path = os.path.join(tmp_dir, "conanfile.py") conanfile = """from base_recipe import BasePackage class Pkg(BasePackage): pass """ base_recipe = """from conans import ConanFile class BasePackage(ConanFile): short_paths = True """ save(conanfile_path, conanfile) save(os.path.join(tmp_dir, "base_recipe.py"), base_recipe) conan_file = load_conanfile_class(conanfile_path) self.assertEqual(conan_file.short_paths, True) result = loader.load_conan(conanfile_path, output=None, consumer=True) self.assertEqual(result.short_paths, True)
def inherit_short_paths_test(self): loader = ConanFileLoader(None, Settings(), Profile()) tmp_dir = temp_folder() conanfile_path = os.path.join(tmp_dir, "conanfile.py") conanfile = """from base_recipe import BasePackage class Pkg(BasePackage): pass """ base_recipe = """from conans import ConanFile class BasePackage(ConanFile): short_paths = True """ save(conanfile_path, conanfile) save(os.path.join(tmp_dir, "base_recipe.py"), base_recipe) conan_file = load_conanfile_class(conanfile_path) self.assertEqual(conan_file.short_paths, True) result = loader.load_conan(conanfile_path, output=None, consumer=True) self.assertEqual(result.short_paths, True)
def upload(self, recorder, reference_or_pattern, package_id=None, all_packages=None, force=False, confirm=False, retry=0, retry_wait=0, skip_upload=False, integrity_check=False, no_overwrite=None, remote_name=None): """If package_id is provided, conan_reference_or_pattern is a ConanFileReference""" if package_id and not _is_a_reference(reference_or_pattern): raise ConanException("-p parameter only allowed with a valid recipe reference, " "not with a pattern") t1 = time.time() if package_id or _is_a_reference(reference_or_pattern): # Upload package ref = ConanFileReference.loads(reference_or_pattern) references = [ref, ] confirm = True else: references = self._cache_search.search_recipes(reference_or_pattern) if not references: raise NotFoundException(("No packages found matching pattern '%s'" % reference_or_pattern)) for conan_ref in references: upload = True if not confirm: msg = "Are you sure you want to upload '%s'?" % str(conan_ref) upload = self._user_io.request_boolean(msg) if upload: try: conanfile_path = self._client_cache.conanfile(conan_ref) conan_file = load_conanfile_class(conanfile_path) except NotFoundException: raise NotFoundException(("There is no local conanfile exported as %s" % str(conan_ref))) if all_packages: packages_ids = self._client_cache.conan_packages(conan_ref) elif package_id: packages_ids = [package_id, ] else: packages_ids = [] self._upload(conan_file, conan_ref, force, packages_ids, retry, retry_wait, skip_upload, integrity_check, no_overwrite, remote_name, recorder) logger.debug("====> Time manager upload: %f" % (time.time() - t1))
def load_conan(self, conanfile_path, output, consumer=False, reference=None, local=False): """ loads a ConanFile object from the given file """ result = load_conanfile_class(conanfile_path) try: # Prepare the settings for the loaded conanfile # Mixing the global settings with the specified for that name if exist tmp_settings = self._settings.copy() if self._package_settings and result.name in self._package_settings: # Update the values, keeping old ones (confusing assign) values_tuple = self._package_settings[result.name] tmp_settings.values = Values.from_list(values_tuple) if reference: result.name = reference.name result.version = reference.version user, channel = reference.user, reference.channel else: user, channel = None, None # Instance the conanfile result = result(output, self._runner, tmp_settings, user, channel, local) # Assign environment result._env_values.update(self._env_values) if consumer: self._user_options.descope_options(result.name) result.options.initialize_upstream(self._user_options, local=local) self._user_options.clear_unscoped_options() else: result.in_local_cache = True if consumer or (self.dev_reference and self.dev_reference == reference): result.develop = True return result except Exception as e: # re-raise with file name raise ConanException("%s: %s" % (conanfile_path, str(e)))
def add_common_builds(self, shared_option_name=None, pure_c=True, dll_with_static_runtime=False, reference=None): if not reference and not self.reference: raise Exception( "Specify a CONAN_REFERENCE or name and version fields in the recipe" ) if shared_option_name is None: if os.path.exists("conanfile.py"): conanfile = load_conanfile_class("./conanfile.py") if hasattr(conanfile, "options") and "shared" in conanfile.options: shared_option_name = "%s:shared" % self.reference.name tmp = self.build_generator.get_builds(pure_c, shared_option_name, dll_with_static_runtime, reference or self.reference) self._builds.extend(tmp)
def copy(self, reference, package_ids, username, channel, force=False): """ Copy or move conanfile (exported) and packages to another user and or channel @param reference: ConanFileReference containing the packages to be moved @param package_ids: list of ids or [] for all list @param username: Destination username @param channel: Destination channel @param remote: install only from that remote """ # It is necessary to make sure the sources are complete before proceeding remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, None) remote_proxy.complete_recipe_sources(reference) # Now we can actually copy conan_file_path = self._client_cache.conanfile(reference) conanfile = load_conanfile_class(conan_file_path) copier = PackageCopier(self._client_cache, self._user_io, conanfile.short_paths) if not package_ids: packages = self._client_cache.packages(reference) if os.path.exists(packages): package_ids = os.listdir(packages) else: package_ids = [] copier.copy(reference, package_ids, username, channel, force)
def download(self, reference, package_ids, remote_name, recipe): """ Download conanfile and specified packages to local repository @param reference: ConanFileReference @param package_ids: Package ids or empty for download all @param remote: install only from that remote @param only_recipe: download only the recipe """ assert(isinstance(reference, ConanFileReference)) remote_proxy = self.get_proxy(remote_name=remote_name) remote, _ = remote_proxy._get_remote() package = self._remote_manager.search_recipes(remote, reference, None) if not package: # Search the reference first, and raise if it doesn't exist raise ConanException("'%s' not found in remote" % str(reference)) # First of all download package recipe remote_proxy.get_recipe(reference, check_updates=True, update=True) if recipe: return # Download the sources too, don't be lazy conan_file_path = self._client_cache.conanfile(reference) conanfile = load_conanfile_class(conan_file_path) complete_recipe_sources(self._remote_manager, self._client_cache, self._registry, conanfile, reference) if package_ids: remote_proxy.download_packages(reference, package_ids) else: self._user_io.out.info("Getting the complete package list " "from '%s'..." % str(reference)) packages_props = self._remote_manager.search_packages(remote, reference, None) if not packages_props: output = ScopedOutput(str(reference), self._user_io.out) output.warn("No remote binary packages found in remote") else: remote_proxy.download_packages(reference, list(packages_props.keys()))
def download(reference, package_ids, remote_name, recipe, registry, remote_manager, client_cache, out, recorder): assert(isinstance(reference, ConanFileReference)) output = ScopedOutput(str(reference), out) remote = registry.remote(remote_name) if remote_name else registry.default_remote package = remote_manager.search_recipes(remote, reference, None) if not package: # Search the reference first, and raise if it doesn't exist raise ConanException("'%s' not found in remote" % str(reference)) # First of all download package recipe remote_manager.get_recipe(reference, remote) registry.set_ref(reference, remote) if recipe: return # Download the sources too, don't be lazy conan_file_path = client_cache.conanfile(reference) conanfile = load_conanfile_class(conan_file_path) complete_recipe_sources(remote_manager, client_cache, registry, conanfile, reference) if package_ids: _download_binaries(reference, package_ids, client_cache, remote_manager, remote, output, recorder) else: output.info("Getting the complete package list " "from '%s'..." % str(reference)) packages_props = remote_manager.search_packages(remote, reference, None) if not packages_props: output = ScopedOutput(str(reference), out) output.warn("No remote binary packages found in remote") else: _download_binaries(reference, list(packages_props.keys()), client_cache, remote_manager, remote, output, recorder)
def create(self, conanfile_path, name=None, version=None, user=None, channel=None, profile_name=None, settings=None, options=None, env=None, test_folder=None, not_export=False, build_modes=None, keep_source=False, keep_build=False, verify=None, manifests=None, manifests_interactive=None, remote=None, update=False, cwd=None, test_build_folder=None): """ API method to create a conan package :param test_folder: default None - looks for default 'test' or 'test_package' folder), string - test_folder path False - disabling tests """ settings = settings or [] options = options or [] env = env or [] cwd = cwd or os.getcwd() conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True) if not name or not version: conanfile = load_conanfile_class(conanfile_path) name, version = conanfile.name, conanfile.version if not name or not version: raise ConanException("conanfile.py doesn't declare package name or version") reference = ConanFileReference(name, version, user, channel) scoped_output = ScopedOutput(str(reference), self._user_io.out) # Make sure keep_source is set for keep_build if keep_build: keep_source = True # Forcing an export! if not not_export: scoped_output.highlight("Exporting package recipe") self._manager.export(conanfile_path, name, version, user, channel, keep_source) if build_modes is None: # Not specified, force build the tested library build_modes = [name] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, cwd, self._client_cache) def get_test_conanfile_path(tf): """Searches in the declared test_folder or in the standard locations""" if tf is False: # Look up for testing conanfile can be disabled if tf (test folder) is False return None test_folders = [tf] if tf else ["test_package", "test"] base_folder = os.path.dirname(conanfile_path) for test_folder_name in test_folders: test_folder = os.path.join(base_folder, test_folder_name) test_conanfile_path = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile_path): return test_conanfile_path else: if tf: raise ConanException("test folder '%s' not available, " "or it doesn't have a conanfile.py" % tf) test_conanfile_path = get_test_conanfile_path(test_folder) if test_conanfile_path: pt = PackageTester(self._manager, self._user_io) pt.install_build_and_test(test_conanfile_path, reference, profile, remote, update, build_modes=build_modes, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, keep_build=keep_build, test_build_folder=test_build_folder) else: self._manager.install(reference=reference, install_folder=None, # Not output anything manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, build_modes=build_modes, update=update, keep_build=keep_build)
def load_cf_class(path, conan_api): if Version(client_version) < Version("1.7.0"): from conans.client.loader_parse import load_conanfile_class return load_conanfile_class(path) else: return conan_api._loader.load_class(path)
def __init__(self, args=None, username=None, channel=None, runner=None, gcc_versions=None, visual_versions=None, visual_runtimes=None, apple_clang_versions=None, archs=None, use_docker=None, curpage=None, total_pages=None, docker_image=None, reference=None, password=None, remotes=None, upload=None, stable_branch_pattern=None, vs10_x86_64_enabled=False, mingw_configurations=None, stable_channel=None, platform_info=None, upload_retry=None, clang_versions=None, login_username=None, upload_only_when_stable=None, build_types=None, skip_check_credentials=False, allow_gcc_minors=False, exclude_vcvars_precommand=False, docker_image_skip_update=False, docker_image_skip_pull=False, docker_entry_script=None, docker_32_images=None, build_policy=None, always_update_conan_in_docker=False, conan_api=None, client_cache=None, ci_manager=None, out=None, test_folder=None): self.printer = Printer(out) self.printer.print_rule() self.printer.print_ascci_art() if not conan_api: self.conan_api, self.client_cache, _ = Conan.factory() else: self.conan_api = conan_api self.client_cache = client_cache self.ci_manager = ci_manager or CIManager(self.printer) self.remotes_manager = RemotesManager(self.conan_api, self.printer, remotes, upload) self.username = username or os.getenv("CONAN_USERNAME", None) if not self.username: raise Exception( "Instance ConanMultiPackage with 'username' parameter or use " "CONAN_USERNAME env variable") self.skip_check_credentials = skip_check_credentials or \ os.getenv("CONAN_SKIP_CHECK_CREDENTIALS", False) self.auth_manager = AuthManager( self.conan_api, self.printer, login_username, password, default_username=self.username, skip_check_credentials=self.skip_check_credentials) self.uploader = Uploader(self.conan_api, self.remotes_manager, self.auth_manager, self.printer) self._builds = [] self._named_builds = {} self._update_conan_in_docker = ( always_update_conan_in_docker or os.getenv("CONAN_ALWAYS_UPDATE_CONAN_DOCKER", False)) self._platform_info = platform_info or PlatformInfo() self.stable_branch_pattern = stable_branch_pattern or \ os.getenv("CONAN_STABLE_BRANCH_PATTERN", None) self.specified_channel = channel or os.getenv("CONAN_CHANNEL", "testing") self.specified_channel = self.specified_channel.rstrip() self.stable_channel = stable_channel or os.getenv( "CONAN_STABLE_CHANNEL", "stable") self.stable_channel = self.stable_channel.rstrip() self.channel = self._get_channel(self.specified_channel, self.stable_channel) self.partial_reference = reference or os.getenv( "CONAN_REFERENCE", None) if self.partial_reference: if "@" in self.partial_reference: self.reference = ConanFileReference.loads( self.partial_reference) else: name, version = self.partial_reference.split("/") self.reference = ConanFileReference(name, version, self.username, self.channel) else: if not os.path.exists("conanfile.py"): raise Exception( "Conanfile not found, specify a 'reference' parameter with name and version" ) conanfile = load_conanfile_class("./conanfile.py") name, version = conanfile.name, conanfile.version if name and version: self.reference = ConanFileReference(name, version, self.username, self.channel) else: self.reference = None # If CONAN_DOCKER_IMAGE is speified, then use docker is True self.use_docker = (use_docker or os.getenv("CONAN_USE_DOCKER", False) or os.getenv("CONAN_DOCKER_IMAGE", None) is not None) os_name = self._platform_info.system( ) if not self.use_docker else "Linux" self.build_generator = BuildGenerator( reference, os_name, gcc_versions, apple_clang_versions, clang_versions, visual_versions, visual_runtimes, vs10_x86_64_enabled, mingw_configurations, archs, allow_gcc_minors, build_types) build_policy = (build_policy or self.ci_manager.get_commit_build_policy() or os.getenv("CONAN_BUILD_POLICY", None)) if build_policy: if build_policy.lower() not in ("never", "outdated", "missing"): raise Exception( "Invalid build policy, valid values: never, outdated, missing" ) self.build_policy = build_policy self.sudo_docker_command = "" if "CONAN_DOCKER_USE_SUDO" in os.environ: self.sudo_docker_command = "sudo -E" if get_bool_from_env( "CONAN_DOCKER_USE_SUDO") else "" elif platform.system() != "Windows": self.sudo_docker_command = "sudo -E" self.sudo_pip_command = "" if "CONAN_PIP_USE_SUDO" in os.environ: self.sudo_pip_command = "sudo -E" if get_bool_from_env( "CONAN_PIP_USE_SUDO") else "" elif platform.system() != "Windows": self.sudo_pip_command = "sudo -E" self.docker_shell = "" self.docker_conan_home = "" if self.is_wcow: self.docker_conan_home = "C:/Users/ContainerAdministrator" self.docker_shell = "cmd /C" else: self.docker_conan_home = "/home/conan" self.docker_shell = "/bin/sh -c" self.docker_platform_param = "" self.lcow_user_workaround = "" if self.is_lcow: self.docker_platform_param = "--platform=linux" # With LCOW, Docker doesn't respect USER directive in dockerfile yet self.lcow_user_workaround = "sudo su conan && " self.exclude_vcvars_precommand = ( exclude_vcvars_precommand or os.getenv("CONAN_EXCLUDE_VCVARS_PRECOMMAND", False)) self._docker_image_skip_update = ( docker_image_skip_update or os.getenv("CONAN_DOCKER_IMAGE_SKIP_UPDATE", False)) self._docker_image_skip_pull = (docker_image_skip_pull or os.getenv( "CONAN_DOCKER_IMAGE_SKIP_PULL", False)) self.runner = runner or os.system self.output_runner = ConanOutputRunner() self.args = " ".join(args) if args else " ".join(sys.argv[1:]) # Upload related variables self.upload_retry = upload_retry or os.getenv("CONAN_UPLOAD_RETRY", 3) if upload_only_when_stable is not None: self.upload_only_when_stable = upload_only_when_stable else: self.upload_only_when_stable = get_bool_from_env( "CONAN_UPLOAD_ONLY_WHEN_STABLE") self.docker_entry_script = docker_entry_script or os.getenv( "CONAN_DOCKER_ENTRY_SCRIPT") os.environ["CONAN_CHANNEL"] = self.channel # If CONAN_DOCKER_IMAGE is speified, then use docker is True self.use_docker = use_docker or os.getenv("CONAN_USE_DOCKER", False) or \ (os.getenv("CONAN_DOCKER_IMAGE", None) is not None) if docker_32_images is not None: self.docker_32_images = docker_32_images else: self.docker_32_images = os.getenv("CONAN_DOCKER_32_IMAGES", False) self.curpage = curpage or os.getenv("CONAN_CURRENT_PAGE", 1) self.total_pages = total_pages or os.getenv("CONAN_TOTAL_PAGES", 1) self._docker_image = docker_image or os.getenv("CONAN_DOCKER_IMAGE", None) self.conan_pip_package = os.getenv("CONAN_PIP_PACKAGE", "conan==%s" % client_version) if self.conan_pip_package in ("0", "False"): self.conan_pip_package = False self.vs10_x86_64_enabled = vs10_x86_64_enabled self.builds_in_current_page = [] self.test_folder = test_folder or os.getenv("CPT_TEST_FOLDER", None) def valid_pair(var, value): return (isinstance(value, six.string_types) or isinstance(value, bool) or isinstance(value, list) ) and not var.startswith("_") and "password" not in var with self.printer.foldable_output("local_vars"): self.printer.print_dict({ var: value for var, value in self.__dict__.items() if valid_pair(var, value) })
def create(self, conanfile_path, name=None, version=None, user=None, channel=None, profile_name=None, settings=None, options=None, env=None, test_folder=None, not_export=False, build_modes=None, keep_source=False, keep_build=False, verify=None, manifests=None, manifests_interactive=None, remote=None, update=False, cwd=None, test_build_folder=None): """ API method to create a conan package :param test_folder: default None - looks for default 'test' or 'test_package' folder), string - test_folder path False - disabling tests """ settings = settings or [] options = options or [] env = env or [] try: cwd = cwd or os.getcwd() recorder = ActionRecorder() conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True) if not name or not version: conanfile = load_conanfile_class(conanfile_path) name, version = conanfile.name, conanfile.version if not name or not version: raise ConanException( "conanfile.py doesn't declare package name or version") reference = ConanFileReference(name, version, user, channel) scoped_output = ScopedOutput(str(reference), self._user_io.out) # Make sure keep_source is set for keep_build if keep_build: keep_source = True # Forcing an export! if not not_export: scoped_output.highlight("Exporting package recipe") cmd_export(conanfile_path, name, version, user, channel, keep_source, self._user_io.out, self._client_cache) if build_modes is None: # Not specified, force build the tested library build_modes = [name] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, cwd, self._client_cache) manager = self._init_manager(recorder) recorder.add_recipe_being_developed(reference) create(reference, manager, self._user_io, profile, remote, update, build_modes, manifest_folder, manifest_verify, manifest_interactive, keep_build, test_build_folder, test_folder, conanfile_path) return recorder.get_info() except ConanException as exc: recorder.error = True exc.info = recorder.get_info() raise
def create(self, profile_name=None, settings=None, options=None, env=None, scope=None, test_folder=None, not_export=False, build=None, keep_source=False, verify=default_manifest_folder, manifests=default_manifest_folder, manifests_interactive=default_manifest_folder, remote=None, update=False, cwd=None, user=None, channel=None, name=None, version=None): settings = settings or [] options = options or [] env = env or [] cwd = prepare_cwd(cwd) if not name or not version: conanfile_path = os.path.join(cwd, "conanfile.py") conanfile = load_conanfile_class(conanfile_path) name, version = conanfile.name, conanfile.version if not name or not version: raise ConanException("conanfile.py doesn't declare package name or version") reference = ConanFileReference(name, version, user, channel) scoped_output = ScopedOutput(str(reference), self._user_io.out) # Forcing an export! if not not_export: scoped_output.highlight("Exporting package recipe") self._manager.export(user, channel, cwd, keep_source=keep_source, name=name, version=version) if build is None: # Not specified, force build the tested library build = [name] manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd) manifest_folder, manifest_interactive, manifest_verify = manifests profile = profile_from_args(profile_name, settings, options, env, scope, cwd, self._client_cache.profiles_path) self._manager.install(reference=reference, current_path=cwd, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, build_modes=build, update=update ) test_folders = [test_folder] if test_folder else ["test_package", "test"] for test_folder_name in test_folders: test_folder = os.path.join(cwd, test_folder_name) test_conanfile_path = os.path.join(test_folder, "conanfile.py") if os.path.exists(test_conanfile_path): break else: self._user_io.out.warn("test package folder not available, or it doesn't have " "a conanfile.py\nIt is recommended to set a 'test_package' " "while creating packages") return scoped_output.highlight("Testing with 'test_package'") sha = hashlib.sha1("".join(options + settings).encode()).hexdigest() build_folder = os.path.join(test_folder, "build", sha) rmdir(build_folder) test_conanfile = os.path.join(test_folder, CONANFILE) self._manager.install(inject_require=reference, reference=test_folder, current_path=build_folder, manifest_folder=manifest_folder, manifest_verify=manifest_verify, manifest_interactive=manifest_interactive, remote=remote, profile=profile, update=update, generators=["txt"] ) self._manager.build(test_conanfile, test_folder, build_folder, package_folder=None, test=str(reference))