Python arch.get_architecture函数代码示例

	def testLangs(self):
		iface_cache = self.config.iface_cache
		try:
			locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')

			s = solver.DefaultSolver(self.config)
			iface = iface_cache.get_interface('http://foo/Langs.xml')
			self.import_feed(iface.uri, 'Langs.xml')

			# 1 is the oldest, but the only one in our language
			binary_arch = arch.get_architecture(None, 'arch_1')
			s.solve('http://foo/Langs.xml', binary_arch)
			assert s.ready
			self.assertEquals('sha1=1', s.selections[iface].id)

			# 6 is the newest, and close enough, even though not
			# quite the right locale
			binary_arch = arch.get_architecture(None, 'arch_2')
			s.solve('http://foo/Langs.xml', binary_arch)
			assert s.ready
			self.assertEquals('sha1=6', s.selections[iface].id)

			# 9 is the newest, although 7 is a closer match
			binary_arch = arch.get_architecture(None, 'arch_3')
			s.solve('http://foo/Langs.xml', binary_arch)
			assert s.ready
			self.assertEquals('sha1=9', s.selections[iface].id)

			# 11 is the newest we understand
			binary_arch = arch.get_architecture(None, 'arch_4')
			s.solve('http://foo/Langs.xml', binary_arch)
			assert s.ready
			self.assertEquals('sha1=11', s.selections[iface].id)

			# 13 is the newest we understand
			binary_arch = arch.get_architecture(None, 'arch_5')
			s.solve('http://foo/Langs.xml', binary_arch)
			assert s.ready
			self.assertEquals('sha1=13', s.selections[iface].id)

			def check(target_arch, langs, expected):
				s.langs = langs
				binary_arch = arch.get_architecture(None, target_arch)
				s.solve('http://foo/Langs.xml', binary_arch)
				assert s.ready
				self.assertEquals(expected, s.selections[iface].id)

			# We don't understand any, so pick the newest
			check('arch_2', ['es_ES'], 'sha1=6')

			# These two have the same version number. Choose the
			# one most appropriate to our country
			check('arch_6', ['zh_CN'], 'sha1=15')
			check('arch_6', ['zh_TW'], 'sha1=16')

			# Same, but one doesn't have a country code
			check('arch_7', ['bn'], 'sha1=17')
			check('arch_7', ['bn_IN'], 'sha1=18')
		finally:
			locale.setlocale(locale.LC_ALL, '')

	def testMultiArch(self):
		iface_cache = self.config.iface_cache
		s = solver.DefaultSolver(self.config)

		foo = iface_cache.get_interface('http://foo/MultiArch.xml')
		self.import_feed(foo.uri, 'MultiArch.xml')
		lib = iface_cache.get_interface('http://foo/MultiArchLib.xml')
		self.import_feed(lib.uri, 'MultiArchLib.xml')

		# On an i686 system we can only use the i486 implementation

		binary_arch = arch.get_architecture('Linux', 'i686')
		s.solve('http://foo/MultiArch.xml', binary_arch)
		assert s.ready
		assert s.selections[foo].machine == 'i486'
		assert s.selections[lib].machine == 'i486'

		# On an 64 bit system we could use either, but we prefer the 64
		# bit implementation. The i486 version of the library is newer,
		# but we must pick one that is compatible with the main binary.

		binary_arch = arch.get_architecture('Linux', 'x86_64')
		s.solve('http://foo/MultiArch.xml', binary_arch)
		assert s.ready
		assert s.selections[foo].machine == 'x86_64'
		assert s.selections[lib].machine == 'x86_64'

	def testArch(self):
		host_arch = arch.get_host_architecture()
		host_arch2 = arch.get_architecture(None, None)
		self.assertEquals(host_arch.os_ranks, host_arch2.os_ranks)
		self.assertEquals(host_arch.machine_ranks, host_arch2.machine_ranks)

		other = arch.get_architecture('FooBar', 'i486')
		self.assertEquals(2, len(other.os_ranks))

		assert 'FooBar' in other.os_ranks
		assert None in other.os_ranks
		assert 'i486' in other.machine_ranks
		assert 'ppc' not in other.machine_ranks

	def get_arch_for(self, requirements, interface = None):
		"""Return the Architecture we would use when solving for this interface.
		Normally, this architecture is constructed from the OS and CPU type in the requirements,
		using the host platform's settings if these are not given.
		If interface is the root, then we wrap this in a SourceArchitecture if looking
		for source code and (for backwards compatibility) we enable use="testing" dependencies
		if the command is "test".
		@param requirements: the overall requirements for the solve
		@type requirements: L{requirements.Requirements}
		@param interface: the interface of interest
		@type interface: L{model.Interface}
		@return: the architecture that would be used
		@rtype: L{architecture.Architecture}
		@since: 1.9"""
		root_arch = arch.get_architecture(requirements.os, requirements.cpu)
		if interface is None or interface.uri == requirements.interface_uri:
			if requirements.source:
				root_arch = arch.SourceArchitecture(root_arch)
			if requirements.command == 'test':
				# This is for old feeds that have use='testing' instead of the newer
				# 'test' command for giving test-only dependencies.
				root_arch = arch.Architecture(root_arch.os_ranks, root_arch.machine_ranks)
				root_arch.use = frozenset([None, "testing"])
			return root_arch
		# Assume we use the same arch for all descendants
		return root_arch.child_arch

    def __init__(self, config, requirements):
        """
		@param config: The configuration settings to use
		@type config: L{config.Config}
		@param requirements: Details about the program we want to run
		@type requirements: L{requirements.Requirements}
		@since: 0.53
		"""
        self.watchers = []

        assert config
        self.config = config

        assert requirements
        self.requirements = requirements

        self.target_arch = arch.get_architecture(requirements.os, requirements.cpu)

        from zeroinstall.injector.solver import DefaultSolver

        self.solver = DefaultSolver(self.config)

        logger.debug(_("Supported systems: '%s'"), arch.os_ranks)
        logger.debug(_("Supported processors: '%s'"), arch.machine_ranks)

        if requirements.before or requirements.not_before:
            self.solver.extra_restrictions[config.iface_cache.get_interface(requirements.interface_uri)] = [
                model.VersionRangeRestriction(
                    model.parse_version(requirements.before), model.parse_version(requirements.not_before)
                )
            ]

	def testFeedBug(self):
		self.import_feed('http://foo/Build.xml', 'Build.xml')
		self.import_feed('http://foo/Compiler.xml', 'Compiler.xml')
		self.import_feed('http://foo/Compiler-new.xml', 'Compiler-new.xml')
		s = solver.DefaultSolver(self.config)
		s.solve('http://foo/Build.xml', arch.get_architecture(None, None))
		assert s.ready, s.get_failure_reason()
		assert s.selections

def assertSelection(expected, repo):
	cache = TestCache()

	expected = [tuple(e.strip().split('-')) for e in expected.split(",")]

	for line in repo.split('\n'):
		line = line.strip()
		if not line: continue
		if ':' in line:
			prog, versions = line.split(':')
			prog = prog.strip()
			if ' ' in prog:
				prog, prog_arch = prog.split()
			else:
				prog_arch = None
			for v in versions.split():
				cache.get_prog(prog).get_version(v).arch = prog_arch
		elif '=>' in line:
			prog, requires = line.split('=>')
			prog, version_range = prog.strip().split('[')
			lib, min_v, max_v = requires.split()
			assert version_range.endswith(']')
			version_range = version_range[:-1]
			if ',' in version_range:
				min_p, max_p = map(int, version_range.split(','))
				prog_versions = range(min_p, max_p + 1)
			else:
				prog_versions = [int(version_range)]
			for prog_version in prog_versions:
				cache.get_prog(prog).get_version(str(prog_version)).add_requires(lib, min_v, max_v)

	root = uri_prefix + expected[0][0]

	class TestConfig:
		help_with_testing = False
		network_use = model.network_offline
		stores = stores
		iface_cache = cache

	s = Solver(TestConfig())
	s.solve(root, arch.get_architecture('Linux', 'x86_64'))

	if expected[0][1] == 'FAIL':
		assert not s.ready
	else:
		assert s.ready

		actual = []
		for iface_uri, impl in s.selections.selections.items():
			actual.append(((iface_uri.rsplit('/', 1)[1]), impl.version))

		expected.sort()
		actual.sort()
		if expected != actual:
			raise Exception("Solve failed:\nExpected: %s\n  Actual: %s" % (expected, actual))
	return s

	def solve_for(self, requirements):
		"""Solve for given requirements.
		@param requirements: the interface, architecture and command to solve for
		@type requirements: L{requirements.Requirements}
		@postcondition: self.ready, self.selections and self.feeds_used are updated
		@since: 1.8"""
		root_arch = arch.get_architecture(requirements.os, requirements.cpu)
		if requirements.source:
			root_arch = arch.SourceArchitecture(root_arch)
		return self.solve(requirements.interface_uri, root_arch, requirements.command)

	def __init__(self, root = None, handler = None, src = None, command = -1, config = None, requirements = None):
		"""
		@param requirements: Details about the program we want to run
		@type requirements: L{requirements.Requirements}
		@param config: The configuration settings to use, or None to load from disk.
		@type config: L{ConfigParser.ConfigParser}
		Note: all other arguments are deprecated (since 0launch 0.52)
		"""
		self.watchers = []
		if requirements is None:
			from zeroinstall.injector.requirements import Requirements
			requirements = Requirements(root)
			requirements.source = bool(src)				# Root impl must be a "src" machine type
			if command == -1:
				if src:
					command = 'compile'
				else:
					command = 'run'
			requirements.command = command
			self.target_arch = arch.get_host_architecture()
		else:
			assert root == src == None
			assert command == -1
			self.target_arch = arch.get_architecture(requirements.os, requirements.cpu)
		self.requirements = requirements

		self.stale_feeds = set()

		if config is None:
			self.config = load_config(handler or Handler())
		else:
			assert handler is None, "can't pass a handler and a config"
			self.config = config

		from zeroinstall.injector.solver import DefaultSolver
		self.solver = DefaultSolver(self.config)

		# If we need to download something but can't because we are offline,
		# warn the user. But only the first time.
		self._warned_offline = False

		debug(_("Supported systems: '%s'"), arch.os_ranks)
		debug(_("Supported processors: '%s'"), arch.machine_ranks)

		if requirements.before or requirements.not_before:
			self.solver.extra_restrictions[config.iface_cache.get_interface(requirements.interface_uri)] = [
					model.VersionRangeRestriction(model.parse_version(requirements.before),
								      model.parse_version(requirements.not_before))]

	def testRanking(self):
		iface_cache = self.config.iface_cache
		s = solver.DefaultSolver(self.config)
		ranking = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'Ranking.xml')

		binary_arch = arch.get_architecture('Linux', 'x86_64')
		selected = []
		while True:
			s.solve(ranking, binary_arch)
			if not s.ready:
				break
			impl = s.selections.selections[ranking]
			selected.append(impl.version + ' ' + impl.attrs['arch'])
			iface_cache.get_feed(ranking).implementations[impl.id].arch = 'Foo-odd'		# prevent reselection
		self.assertEqual([
			'0.2 Linux-i386',	# poor arch, but newest version
			'0.1 Linux-x86_64',	# 64-bit is best match for host arch
			'0.1 Linux-i686', '0.1 Linux-i586', '0.1 Linux-i486'],	# ordering of x86 versions
			selected)

	def testOs(self):
		arch = get_architecture('MacOSX', 'ppc')
		assert ('Darwin' in arch.os_ranks)

	def justify_decision(self, requirements, iface, impl):
		"""Run a solve with impl_id forced to be selected, and explain why it wasn't (or was)
		selected in the normal case.
		@type requirements: L{zeroinstall.injector.requirements.Requirements}
		@type iface: L{zeroinstall.injector.model.Interface}
		@type impl: L{zeroinstall.injector.model.Implementation}
		@rtype: str"""
		assert isinstance(iface, model.Interface), iface

		restrictions = self.extra_restrictions.copy()
		restrictions[iface] = restrictions.get(iface, []) + [_ForceImpl(impl)]
		s = SATSolver(self.config, restrictions)
		s.record_details = True
		s.solve_for(requirements)

		wanted = "{iface} {version}".format(iface = iface.get_name(), version = impl.get_version())

		# Could a selection involving impl even be valid?
		if not s.ready or iface.uri not in s.selections.selections:
			reasons = s.details.get(iface, [])
			for (rid, rstr) in reasons:
				if rid.id == impl.id and rstr is not None:
					return _("{wanted} cannot be used (regardless of other components): {reason}").format(
							wanted = wanted,
							reason = rstr)

			if not s.ready:
				return _("There is no possible selection using {wanted}.\n{reason}").format(
					wanted = wanted,
					reason = s.get_failure_reason())

		actual_selection = self.selections.get(iface, None)
		if actual_selection is not None:
			# Was impl actually selected anyway?
			if actual_selection.id == impl.id:
				return _("{wanted} was selected as the preferred version.").format(wanted = wanted)

			# Was impl ranked below the selected version?
			iface_arch = arch.get_architecture(requirements.os, requirements.cpu)
			if requirements.source and iface.uri == requirements.interface_uri:
				iface_arch = arch.SourceArchitecture(iface_arch)
			wanted_rating = self.get_rating(iface, impl, arch)
			selected_rating = self.get_rating(iface, actual_selection, arch)

			if wanted_rating < selected_rating:
				_ranking_component_reason = [
					_("natural languages we understand are preferred"),
					_("preferred versions come first"),
					_("locally-available versions are preferred when network use is limited"),
					_("packages that don't require admin access to install are preferred"),
					_("more stable versions preferred"),
					_("newer versions are preferred"),
					_("native packages are preferred"),
					_("newer versions are preferred"),
					_("better OS match"),
					_("better CPU match"),
					_("better locale match"),
					_("is locally available"),
					_("better ID (tie-breaker)"),
				]

				actual = actual_selection.get_version()
				if impl.get_version() == actual:
					def detail(i):
						if len(i.id) < 18:
							return " (" + i.id + ")"
						else:
							return " (" + i.id[:16] + "...)"

					wanted += detail(impl)
					actual += detail(actual_selection)

				for i in range(len(wanted_rating)):
					if wanted_rating[i] < selected_rating[i]:
						return _("{wanted} is ranked lower than {actual}: {why}").format(
								wanted = wanted,
								actual = actual,
								why = _ranking_component_reason[i])

		used_impl = iface.uri in s.selections.selections

		# Impl is selectable and ranked higher than the selected version. Selecting it would cause
		# a problem elsewhere.
		changes = []
		for old_iface, old_sel in self.selections.selections.items():
			if old_iface == iface.uri and used_impl: continue
			new_sel = s.selections.selections.get(old_iface, None)
			if new_sel is None:
				changes.append(_("{interface}: no longer used").format(interface = old_iface))
			elif old_sel.version != new_sel.version:
				changes.append(_("{interface}: {old} to {new}").format(interface = old_iface, old = old_sel.version, new = new_sel.version))
			elif old_sel.id != new_sel.id:
				changes.append(_("{interface}: {old} to {new}").format(interface = old_iface, old = old_sel.id, new = new_sel.id))

		if changes:
			changes_text = '\n\n' + _('The changes would be:') + '\n\n' + '\n'.join(changes)
		else:
			changes_text = ''

		if used_impl:
#.........这里部分代码省略.........

	def testMachine(self):
		arch = get_architecture('Linux', 'i686')
		assert ('i386' in arch.machine_ranks)

			def check(target_arch, langs, expected):
				s.langs = langs
				binary_arch = arch.get_architecture(None, target_arch)
				s.solve('http://foo/Langs.xml', binary_arch)
				assert s.ready
				self.assertEquals(expected, s.selections[iface].id)

	def testDefault(self):
		arch = get_architecture(None, None)
		assert arch