Python Values.from_list方法代码示例

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
 def settings_defaults(self, settings):
     default_settings = self.get_conf("settings_defaults")
     values = Values.from_list(default_settings)
     settings.values = values
     mixed_settings = _mix_settings_with_env(default_settings)
     values = Values.from_list(mixed_settings)
     settings.values = values

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
 def from_list(data):
     result = OptionsValues()
     by_package = defaultdict(list)
     for k, v in data:
         tokens = k.split(":")
         if len(tokens) == 2:
             package, option = tokens
             by_package[package.strip()].append((option, v))
         else:
             by_package[None].append((k, v))
     result._options = Values.from_list(by_package[None])
     for k, v in by_package.items():
         if k is not None:
             result._reqs_options[k] = Values.from_list(v)
     return result

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
    def _loader(self, current_path=None, user_settings_values=None, user_options_values=None,
                scopes=None):
        # The disk settings definition, already including the default disk values
        settings = self._paths.settings
        options = OptionsValues()
        conaninfo_scopes = Scopes()

        if current_path:
            conan_info_path = os.path.join(current_path, CONANINFO)
            if os.path.exists(conan_info_path):
                existing_info = ConanInfo.load_file(conan_info_path)
                settings.values = existing_info.full_settings
                options = existing_info.full_options  # Take existing options from conaninfo.txt
                conaninfo_scopes = existing_info.scope

        if user_settings_values:
            aux_values = Values.from_list(user_settings_values)
            settings.values = aux_values

        if user_options_values is not None:  # Install will pass an empty list []
            # Install OVERWRITES options, existing options in CONANINFO are not taken
            # into account, just those from CONANFILE + user command line
            options = OptionsValues.from_list(user_options_values)

        if scopes:
            conaninfo_scopes.update_scope(scopes)

        self._current_scopes = conaninfo_scopes
        return ConanFileLoader(self._runner, settings, options=options, scopes=conaninfo_scopes)

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
    def simple_test(self):
        v = Values()
        self.assertEqual(v.compiler, None)
        v.compiler = 3
        self.assertTrue(v.compiler == "3")

        self.assertEqual(v.compiler.version, None)
        v.compiler.version = "asfaf"
        self.assertEqual(v.compiler.version, "asfaf")

        my_list = v.as_list()
        self.assertEqual(my_list, [("compiler", "3"), ("compiler.version", "asfaf")])

        values = Values.from_list(my_list)
        self.assertEqual(values.dumps(), v.dumps())

        v.compiler = None
        self.assertEqual(v.as_list(), [("compiler", "None")])
        self.assertEqual(v.dumps(), "compiler=None")

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
    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)))

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
 def settings_defaults(self):
     default_settings = self.get_conf("settings_defaults")
     values = Values.from_list(default_settings)
     return values

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
 def values(self):
     result = OptionsValues()
     result._options = Values.from_list(self._options.values_list)
     for k, v in self._reqs_options.items():
         result._reqs_options[k] = v.copy()
     return result

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
 def generate_default_config_file():
     default_settings = detect_defaults_settings(self._output)
     default_setting_values = Values.from_list(default_settings)
     client_conf = default_client_conf + default_setting_values.dumps()
     save(self.conan_conf_path, client_conf)

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
 def values(self):
     return Values.from_list(self.values_list)

# 需要导入模块: from conans.model.values import Values [as 别名]
# 或者: from conans.model.values.Values import from_list [as 别名]
 def settings_values(self):
     return Values.from_list(list(self.settings.items()))