| import sys |
| |
| from pip._internal.pep425tags import get_supported, version_info_to_nodot |
| from pip._internal.utils.misc import normalize_version_info |
| from pip._internal.utils.typing import MYPY_CHECK_RUNNING |
| |
| if MYPY_CHECK_RUNNING: |
| from typing import List, Optional, Tuple |
| from pip._internal.pep425tags import Pep425Tag |
| |
| |
| class TargetPython(object): |
| |
| """ |
| Encapsulates the properties of a Python interpreter one is targeting |
| for a package install, download, etc. |
| """ |
| |
| def __init__( |
| self, |
| platform=None, # type: Optional[str] |
| py_version_info=None, # type: Optional[Tuple[int, ...]] |
| abi=None, # type: Optional[str] |
| implementation=None, # type: Optional[str] |
| ): |
| # type: (...) -> None |
| """ |
| :param platform: A string or None. If None, searches for packages |
| that are supported by the current system. Otherwise, will find |
| packages that can be built on the platform passed in. These |
| packages will only be downloaded for distribution: they will |
| not be built locally. |
| :param py_version_info: An optional tuple of ints representing the |
| Python version information to use (e.g. `sys.version_info[:3]`). |
| This can have length 1, 2, or 3 when provided. |
| :param abi: A string or None. This is passed to pep425tags.py's |
| get_supported() function as is. |
| :param implementation: A string or None. This is passed to |
| pep425tags.py's get_supported() function as is. |
| """ |
| # Store the given py_version_info for when we call get_supported(). |
| self._given_py_version_info = py_version_info |
| |
| if py_version_info is None: |
| py_version_info = sys.version_info[:3] |
| else: |
| py_version_info = normalize_version_info(py_version_info) |
| |
| py_version = '.'.join(map(str, py_version_info[:2])) |
| |
| self.abi = abi |
| self.implementation = implementation |
| self.platform = platform |
| self.py_version = py_version |
| self.py_version_info = py_version_info |
| |
| # This is used to cache the return value of get_tags(). |
| self._valid_tags = None # type: Optional[List[Pep425Tag]] |
| |
| def format_given(self): |
| # type: () -> str |
| """ |
| Format the given, non-None attributes for display. |
| """ |
| display_version = None |
| if self._given_py_version_info is not None: |
| display_version = '.'.join( |
| str(part) for part in self._given_py_version_info |
| ) |
| |
| key_values = [ |
| ('platform', self.platform), |
| ('version_info', display_version), |
| ('abi', self.abi), |
| ('implementation', self.implementation), |
| ] |
| return ' '.join( |
| '{}={!r}'.format(key, value) for key, value in key_values |
| if value is not None |
| ) |
| |
| def get_tags(self): |
| # type: () -> List[Pep425Tag] |
| """ |
| Return the supported PEP 425 tags to check wheel candidates against. |
| |
| The tags are returned in order of preference (most preferred first). |
| """ |
| if self._valid_tags is None: |
| # Pass versions=None if no py_version_info was given since |
| # versions=None uses special default logic. |
| py_version_info = self._given_py_version_info |
| if py_version_info is None: |
| versions = None |
| else: |
| versions = [version_info_to_nodot(py_version_info)] |
| |
| tags = get_supported( |
| versions=versions, |
| platform=self.platform, |
| abi=self.abi, |
| impl=self.implementation, |
| ) |
| self._valid_tags = tags |
| |
| return self._valid_tags |