def _look_for_require(self, require):
try:
python_require = self._cached_requires[require]
except KeyError:
ref = ConanFileReference.loads(require)
requirement = Requirement(ref)
self._range_resolver.resolve(requirement,
"python_require",
update=False,
remote_name=None)
ref = requirement.ref
result = self._proxy.get_recipe(ref,
self._check_updates,
self._update,
remote_name=self._remote_name,
recorder=ActionRecorder())
path, _, _, new_ref = result
module, conanfile = parse_conanfile(conanfile_path=path,
python_requires=self)
# Check for alias
if getattr(conanfile, "alias", None):
# Will register also the aliased
python_require = self._look_for_require(conanfile.alias)
else:
python_require = PythonRequire(new_ref, module, conanfile)
self._cached_requires[require] = python_require
return python_require
def _look_for_require(self, reference):
ref = ConanFileReference.loads(reference)
ref = self.locked_versions[ref.name] if self.locked_versions is not None else ref
try:
python_require = self._cached_requires[ref]
except KeyError:
requirement = Requirement(ref)
self._range_resolver.resolve(requirement, "python_require", update=self._update,
remotes=self._remotes)
ref = requirement.ref
result = self._proxy.get_recipe(ref, self._check_updates, self._update,
remotes=self._remotes,
recorder=ActionRecorder())
path, _, _, new_ref = result
module, conanfile = parse_conanfile(conanfile_path=path, python_requires=self)
# Check for alias
if getattr(conanfile, "alias", None):
# Will register also the aliased
python_require = self._look_for_require(conanfile.alias)
else:
package_layout = self._proxy._cache.package_layout(new_ref, conanfile.short_paths)
exports_sources_folder = package_layout.export_sources()
exports_folder = package_layout.export()
python_require = PythonRequire(new_ref, module, conanfile,
exports_folder, exports_sources_folder)
self._cached_requires[ref] = python_require
return python_require
def _do_actual_test(self, scm_data, after_scm, after_recipe):
target_conanfile = self.conanfile.format(url=scm_data['url'],
revision=scm_data['revision'],
after_scm=after_scm,
after_recipe=after_recipe)
save(self.conanfile_path,
content=self.conanfile.format(url='auto',
revision='auto',
after_scm=after_scm,
after_recipe=after_recipe))
scm_data = SCMData(conanfile=namedtuple('_', 'scm')(scm=scm_data))
_replace_scm_data_in_conanfile(self.conanfile_path, scm_data)
self.assertEqual(load(self.conanfile_path), target_conanfile)
parse_conanfile(
self.conanfile_path
) # Check that the resulting file is valid python code.
def upload(conan_api):
remote, user, password = get_remote(conan_api)
conan_api.authenticate(user, password, remote)
(_, conanfile) = parse_conanfile('./conanfile.py',
ConanPythonRequire(None, None))
conan_api.upload(pattern="{}/{}@arobasmusic/{}".format(
conanfile.name, conanfile.version, get_channel()),
remote_name=remote)
def _check_result(self, conanfile):
content = load(conanfile)
self.assertEqual(content.count(self.scm_data['url']), 1)
self.assertEqual(content.count(self.scm_data['revision']), 1)
self.assertIn(self.scm_data['url'], content)
self.assertIn(self.scm_data['revision'], content)
try:
# Check it is loadable by Conan machinery
_, conanfile = parse_conanfile(
conanfile, python_requires=self.python_requires)
except Exception as e:
self.fail("Invalid conanfile: {}".format(e))
else:
self.assertEqual(conanfile.scm, self.scm_data)
def __call__(self, require):
try:
python_require = self._cached_requires[require]
except KeyError:
r = ConanFileReference.loads(require)
requirement = Requirement(r)
self._range_resolver.resolve(requirement,
"python_require",
update=False,
remote_name=None)
r = requirement.conan_reference
result = self._proxy.get_recipe(r,
False,
False,
remote_name=None,
recorder=ActionRecorder())
path, _, _, reference = result
module, _ = parse_conanfile(path)
python_require = PythonRequire(reference, module)
self._cached_requires[require] = python_require
self._requires.append(python_require)
return python_require.module