Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/pip/_vendor/distro/distro.py: 61%

1#!/usr/bin/env python 

2# Copyright 2015,2016,2017 Nir Cohen 

3# 

4# Licensed under the Apache License, Version 2.0 (the "License"); 

5# you may not use this file except in compliance with the License. 

6# You may obtain a copy of the License at 

7# 

8# http://www.apache.org/licenses/LICENSE-2.0 

9# 

10# Unless required by applicable law or agreed to in writing, software 

11# distributed under the License is distributed on an "AS IS" BASIS, 

12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 

13# See the License for the specific language governing permissions and 

14# limitations under the License. 

15 

16""" 

17The ``distro`` package (``distro`` stands for Linux Distribution) provides 

18information about the Linux distribution it runs on, such as a reliable 

19machine-readable distro ID, or version information. 

20 

21It is the recommended replacement for Python's original 

22:py:func:`platform.linux_distribution` function, but it provides much more 

23functionality. An alternative implementation became necessary because Python 

243.5 deprecated this function, and Python 3.8 removed it altogether. Its 

25predecessor function :py:func:`platform.dist` was already deprecated since 

26Python 2.6 and removed in Python 3.8. Still, there are many cases in which 

27access to OS distribution information is needed. See `Python issue 1322 

28<https://bugs.python.org/issue1322>`_ for more information. 

29""" 

30 

31import argparse 

32import json 

33import logging 

34import os 

35import re 

36import shlex 

37import subprocess 

38import sys 

39import warnings 

40from typing import ( 

41 Any, 

42 Callable, 

43 Dict, 

44 Iterable, 

45 Optional, 

46 Sequence, 

47 TextIO, 

48 Tuple, 

49 Type, 

50) 

51 

52try: 

53 from typing import TypedDict 

54except ImportError: 

55 # Python 3.7 

56 TypedDict = dict 

57 

58__version__ = "1.8.0" 

59 

60 

61class VersionDict(TypedDict): 

62 major: str 

63 minor: str 

64 build_number: str 

65 

66 

67class InfoDict(TypedDict): 

68 id: str 

69 version: str 

70 version_parts: VersionDict 

71 like: str 

72 codename: str 

73 

74 

75_UNIXCONFDIR = os.environ.get("UNIXCONFDIR", "/etc") 

76_UNIXUSRLIBDIR = os.environ.get("UNIXUSRLIBDIR", "/usr/lib") 

77_OS_RELEASE_BASENAME = "os-release" 

78 

79#: Translation table for normalizing the "ID" attribute defined in os-release 

80#: files, for use by the :func:`distro.id` method. 

81#: 

82#: * Key: Value as defined in the os-release file, translated to lower case, 

83#: with blanks translated to underscores. 

84#: 

85#: * Value: Normalized value. 

86NORMALIZED_OS_ID = { 

87 "ol": "oracle", # Oracle Linux 

88 "opensuse-leap": "opensuse", # Newer versions of OpenSuSE report as opensuse-leap 

89} 

90 

91#: Translation table for normalizing the "Distributor ID" attribute returned by 

92#: the lsb_release command, for use by the :func:`distro.id` method. 

93#: 

94#: * Key: Value as returned by the lsb_release command, translated to lower 

95#: case, with blanks translated to underscores. 

96#: 

97#: * Value: Normalized value. 

98NORMALIZED_LSB_ID = { 

99 "enterpriseenterpriseas": "oracle", # Oracle Enterprise Linux 4 

100 "enterpriseenterpriseserver": "oracle", # Oracle Linux 5 

101 "redhatenterpriseworkstation": "rhel", # RHEL 6, 7 Workstation 

102 "redhatenterpriseserver": "rhel", # RHEL 6, 7 Server 

103 "redhatenterprisecomputenode": "rhel", # RHEL 6 ComputeNode 

104} 

105 

106#: Translation table for normalizing the distro ID derived from the file name 

107#: of distro release files, for use by the :func:`distro.id` method. 

108#: 

109#: * Key: Value as derived from the file name of a distro release file, 

110#: translated to lower case, with blanks translated to underscores. 

111#: 

112#: * Value: Normalized value. 

113NORMALIZED_DISTRO_ID = { 

114 "redhat": "rhel", # RHEL 6.x, 7.x 

115} 

116 

117# Pattern for content of distro release file (reversed) 

118_DISTRO_RELEASE_CONTENT_REVERSED_PATTERN = re.compile( 

119 r"(?:[^)]*\)(.*)\()? *(?:STL )?([\d.+\-a-z]*\d) *(?:esaeler *)?(.+)" 

120) 

121 

122# Pattern for base file name of distro release file 

123_DISTRO_RELEASE_BASENAME_PATTERN = re.compile(r"(\w+)[-_](release|version)$") 

124 

125# Base file names to be looked up for if _UNIXCONFDIR is not readable. 

126_DISTRO_RELEASE_BASENAMES = [ 

127 "SuSE-release", 

128 "arch-release", 

129 "base-release", 

130 "centos-release", 

131 "fedora-release", 

132 "gentoo-release", 

133 "mageia-release", 

134 "mandrake-release", 

135 "mandriva-release", 

136 "mandrivalinux-release", 

137 "manjaro-release", 

138 "oracle-release", 

139 "redhat-release", 

140 "rocky-release", 

141 "sl-release", 

142 "slackware-version", 

143] 

144 

145# Base file names to be ignored when searching for distro release file 

146_DISTRO_RELEASE_IGNORE_BASENAMES = ( 

147 "debian_version", 

148 "lsb-release", 

149 "oem-release", 

150 _OS_RELEASE_BASENAME, 

151 "system-release", 

152 "plesk-release", 

153 "iredmail-release", 

154) 

155 

156 

157def linux_distribution(full_distribution_name: bool = True) -> Tuple[str, str, str]: 

158 """ 

159 .. deprecated:: 1.6.0 

160 

161 :func:`distro.linux_distribution()` is deprecated. It should only be 

162 used as a compatibility shim with Python's 

163 :py:func:`platform.linux_distribution()`. Please use :func:`distro.id`, 

164 :func:`distro.version` and :func:`distro.name` instead. 

165 

166 Return information about the current OS distribution as a tuple 

167 ``(id_name, version, codename)`` with items as follows: 

168 

169 * ``id_name``: If *full_distribution_name* is false, the result of 

170 :func:`distro.id`. Otherwise, the result of :func:`distro.name`. 

171 

172 * ``version``: The result of :func:`distro.version`. 

173 

174 * ``codename``: The extra item (usually in parentheses) after the 

175 os-release version number, or the result of :func:`distro.codename`. 

176 

177 The interface of this function is compatible with the original 

178 :py:func:`platform.linux_distribution` function, supporting a subset of 

179 its parameters. 

180 

181 The data it returns may not exactly be the same, because it uses more data 

182 sources than the original function, and that may lead to different data if 

183 the OS distribution is not consistent across multiple data sources it 

184 provides (there are indeed such distributions ...). 

185 

186 Another reason for differences is the fact that the :func:`distro.id` 

187 method normalizes the distro ID string to a reliable machine-readable value 

188 for a number of popular OS distributions. 

189 """ 

190 warnings.warn( 

191 "distro.linux_distribution() is deprecated. It should only be used as a " 

192 "compatibility shim with Python's platform.linux_distribution(). Please use " 

193 "distro.id(), distro.version() and distro.name() instead.", 

194 DeprecationWarning, 

195 stacklevel=2, 

196 ) 

197 return _distro.linux_distribution(full_distribution_name) 

198 

199 

200def id() -> str: 

201 """ 

202 Return the distro ID of the current distribution, as a 

203 machine-readable string. 

204 

205 For a number of OS distributions, the returned distro ID value is 

206 *reliable*, in the sense that it is documented and that it does not change 

207 across releases of the distribution. 

208 

209 This package maintains the following reliable distro ID values: 

210 

211 ============== ========================================= 

212 Distro ID Distribution 

213 ============== ========================================= 

214 "ubuntu" Ubuntu 

215 "debian" Debian 

216 "rhel" RedHat Enterprise Linux 

217 "centos" CentOS 

218 "fedora" Fedora 

219 "sles" SUSE Linux Enterprise Server 

220 "opensuse" openSUSE 

221 "amzn" Amazon Linux 

222 "arch" Arch Linux 

223 "buildroot" Buildroot 

224 "cloudlinux" CloudLinux OS 

225 "exherbo" Exherbo Linux 

226 "gentoo" GenToo Linux 

227 "ibm_powerkvm" IBM PowerKVM 

228 "kvmibm" KVM for IBM z Systems 

229 "linuxmint" Linux Mint 

230 "mageia" Mageia 

231 "mandriva" Mandriva Linux 

232 "parallels" Parallels 

233 "pidora" Pidora 

234 "raspbian" Raspbian 

235 "oracle" Oracle Linux (and Oracle Enterprise Linux) 

236 "scientific" Scientific Linux 

237 "slackware" Slackware 

238 "xenserver" XenServer 

239 "openbsd" OpenBSD 

240 "netbsd" NetBSD 

241 "freebsd" FreeBSD 

242 "midnightbsd" MidnightBSD 

243 "rocky" Rocky Linux 

244 "aix" AIX 

245 "guix" Guix System 

246 ============== ========================================= 

247 

248 If you have a need to get distros for reliable IDs added into this set, 

249 or if you find that the :func:`distro.id` function returns a different 

250 distro ID for one of the listed distros, please create an issue in the 

251 `distro issue tracker`_. 

252 

253 **Lookup hierarchy and transformations:** 

254 

255 First, the ID is obtained from the following sources, in the specified 

256 order. The first available and non-empty value is used: 

257 

258 * the value of the "ID" attribute of the os-release file, 

259 

260 * the value of the "Distributor ID" attribute returned by the lsb_release 

261 command, 

262 

263 * the first part of the file name of the distro release file, 

264 

265 The so determined ID value then passes the following transformations, 

266 before it is returned by this method: 

267 

268 * it is translated to lower case, 

269 

270 * blanks (which should not be there anyway) are translated to underscores, 

271 

272 * a normalization of the ID is performed, based upon 

273 `normalization tables`_. The purpose of this normalization is to ensure 

274 that the ID is as reliable as possible, even across incompatible changes 

275 in the OS distributions. A common reason for an incompatible change is 

276 the addition of an os-release file, or the addition of the lsb_release 

277 command, with ID values that differ from what was previously determined 

278 from the distro release file name. 

279 """ 

280 return _distro.id() 

281 

282 

283def name(pretty: bool = False) -> str: 

284 """ 

285 Return the name of the current OS distribution, as a human-readable 

286 string. 

287 

288 If *pretty* is false, the name is returned without version or codename. 

289 (e.g. "CentOS Linux") 

290 

291 If *pretty* is true, the version and codename are appended. 

292 (e.g. "CentOS Linux 7.1.1503 (Core)") 

293 

294 **Lookup hierarchy:** 

295 

296 The name is obtained from the following sources, in the specified order. 

297 The first available and non-empty value is used: 

298 

299 * If *pretty* is false: 

300 

301 - the value of the "NAME" attribute of the os-release file, 

302 

303 - the value of the "Distributor ID" attribute returned by the lsb_release 

304 command, 

305 

306 - the value of the "<name>" field of the distro release file. 

307 

308 * If *pretty* is true: 

309 

310 - the value of the "PRETTY_NAME" attribute of the os-release file, 

311 

312 - the value of the "Description" attribute returned by the lsb_release 

313 command, 

314 

315 - the value of the "<name>" field of the distro release file, appended 

316 with the value of the pretty version ("<version_id>" and "<codename>" 

317 fields) of the distro release file, if available. 

318 """ 

319 return _distro.name(pretty) 

320 

321 

322def version(pretty: bool = False, best: bool = False) -> str: 

323 """ 

324 Return the version of the current OS distribution, as a human-readable 

325 string. 

326 

327 If *pretty* is false, the version is returned without codename (e.g. 

328 "7.0"). 

329 

330 If *pretty* is true, the codename in parenthesis is appended, if the 

331 codename is non-empty (e.g. "7.0 (Maipo)"). 

332 

333 Some distributions provide version numbers with different precisions in 

334 the different sources of distribution information. Examining the different 

335 sources in a fixed priority order does not always yield the most precise 

336 version (e.g. for Debian 8.2, or CentOS 7.1). 

337 

338 Some other distributions may not provide this kind of information. In these 

339 cases, an empty string would be returned. This behavior can be observed 

340 with rolling releases distributions (e.g. Arch Linux). 

341 

342 The *best* parameter can be used to control the approach for the returned 

343 version: 

344 

345 If *best* is false, the first non-empty version number in priority order of 

346 the examined sources is returned. 

347 

348 If *best* is true, the most precise version number out of all examined 

349 sources is returned. 

350 

351 **Lookup hierarchy:** 

352 

353 In all cases, the version number is obtained from the following sources. 

354 If *best* is false, this order represents the priority order: 

355 

356 * the value of the "VERSION_ID" attribute of the os-release file, 

357 * the value of the "Release" attribute returned by the lsb_release 

358 command, 

359 * the version number parsed from the "<version_id>" field of the first line 

360 of the distro release file, 

361 * the version number parsed from the "PRETTY_NAME" attribute of the 

362 os-release file, if it follows the format of the distro release files. 

363 * the version number parsed from the "Description" attribute returned by 

364 the lsb_release command, if it follows the format of the distro release 

365 files. 

366 """ 

367 return _distro.version(pretty, best) 

368 

369 

370def version_parts(best: bool = False) -> Tuple[str, str, str]: 

371 """ 

372 Return the version of the current OS distribution as a tuple 

373 ``(major, minor, build_number)`` with items as follows: 

374 

375 * ``major``: The result of :func:`distro.major_version`. 

376 

377 * ``minor``: The result of :func:`distro.minor_version`. 

378 

379 * ``build_number``: The result of :func:`distro.build_number`. 

380 

381 For a description of the *best* parameter, see the :func:`distro.version` 

382 method. 

383 """ 

384 return _distro.version_parts(best) 

385 

386 

387def major_version(best: bool = False) -> str: 

388 """ 

389 Return the major version of the current OS distribution, as a string, 

390 if provided. 

391 Otherwise, the empty string is returned. The major version is the first 

392 part of the dot-separated version string. 

393 

394 For a description of the *best* parameter, see the :func:`distro.version` 

395 method. 

396 """ 

397 return _distro.major_version(best) 

398 

399 

400def minor_version(best: bool = False) -> str: 

401 """ 

402 Return the minor version of the current OS distribution, as a string, 

403 if provided. 

404 Otherwise, the empty string is returned. The minor version is the second 

405 part of the dot-separated version string. 

406 

407 For a description of the *best* parameter, see the :func:`distro.version` 

408 method. 

409 """ 

410 return _distro.minor_version(best) 

411 

412 

413def build_number(best: bool = False) -> str: 

414 """ 

415 Return the build number of the current OS distribution, as a string, 

416 if provided. 

417 Otherwise, the empty string is returned. The build number is the third part 

418 of the dot-separated version string. 

419 

420 For a description of the *best* parameter, see the :func:`distro.version` 

421 method. 

422 """ 

423 return _distro.build_number(best) 

424 

425 

426def like() -> str: 

427 """ 

428 Return a space-separated list of distro IDs of distributions that are 

429 closely related to the current OS distribution in regards to packaging 

430 and programming interfaces, for example distributions the current 

431 distribution is a derivative from. 

432 

433 **Lookup hierarchy:** 

434 

435 This information item is only provided by the os-release file. 

436 For details, see the description of the "ID_LIKE" attribute in the 

437 `os-release man page 

438 <http://www.freedesktop.org/software/systemd/man/os-release.html>`_. 

439 """ 

440 return _distro.like() 

441 

442 

443def codename() -> str: 

444 """ 

445 Return the codename for the release of the current OS distribution, 

446 as a string. 

447 

448 If the distribution does not have a codename, an empty string is returned. 

449 

450 Note that the returned codename is not always really a codename. For 

451 example, openSUSE returns "x86_64". This function does not handle such 

452 cases in any special way and just returns the string it finds, if any. 

453 

454 **Lookup hierarchy:** 

455 

456 * the codename within the "VERSION" attribute of the os-release file, if 

457 provided, 

458 

459 * the value of the "Codename" attribute returned by the lsb_release 

460 command, 

461 

462 * the value of the "<codename>" field of the distro release file. 

463 """ 

464 return _distro.codename() 

465 

466 

467def info(pretty: bool = False, best: bool = False) -> InfoDict: 

468 """ 

469 Return certain machine-readable information items about the current OS 

470 distribution in a dictionary, as shown in the following example: 

471 

472 .. sourcecode:: python 

473 

474 { 

475 'id': 'rhel', 

476 'version': '7.0', 

477 'version_parts': { 

478 'major': '7', 

479 'minor': '0', 

480 'build_number': '' 

481 }, 

482 'like': 'fedora', 

483 'codename': 'Maipo' 

484 } 

485 

486 The dictionary structure and keys are always the same, regardless of which 

487 information items are available in the underlying data sources. The values 

488 for the various keys are as follows: 

489 

490 * ``id``: The result of :func:`distro.id`. 

491 

492 * ``version``: The result of :func:`distro.version`. 

493 

494 * ``version_parts -> major``: The result of :func:`distro.major_version`. 

495 

496 * ``version_parts -> minor``: The result of :func:`distro.minor_version`. 

497 

498 * ``version_parts -> build_number``: The result of 

499 :func:`distro.build_number`. 

500 

501 * ``like``: The result of :func:`distro.like`. 

502 

503 * ``codename``: The result of :func:`distro.codename`. 

504 

505 For a description of the *pretty* and *best* parameters, see the 

506 :func:`distro.version` method. 

507 """ 

508 return _distro.info(pretty, best) 

509 

510 

511def os_release_info() -> Dict[str, str]: 

512 """ 

513 Return a dictionary containing key-value pairs for the information items 

514 from the os-release file data source of the current OS distribution. 

515 

516 See `os-release file`_ for details about these information items. 

517 """ 

518 return _distro.os_release_info() 

519 

520 

521def lsb_release_info() -> Dict[str, str]: 

522 """ 

523 Return a dictionary containing key-value pairs for the information items 

524 from the lsb_release command data source of the current OS distribution. 

525 

526 See `lsb_release command output`_ for details about these information 

527 items. 

528 """ 

529 return _distro.lsb_release_info() 

530 

531 

532def distro_release_info() -> Dict[str, str]: 

533 """ 

534 Return a dictionary containing key-value pairs for the information items 

535 from the distro release file data source of the current OS distribution. 

536 

537 See `distro release file`_ for details about these information items. 

538 """ 

539 return _distro.distro_release_info() 

540 

541 

542def uname_info() -> Dict[str, str]: 

543 """ 

544 Return a dictionary containing key-value pairs for the information items 

545 from the distro release file data source of the current OS distribution. 

546 """ 

547 return _distro.uname_info() 

548 

549 

550def os_release_attr(attribute: str) -> str: 

551 """ 

552 Return a single named information item from the os-release file data source 

553 of the current OS distribution. 

554 

555 Parameters: 

556 

557 * ``attribute`` (string): Key of the information item. 

558 

559 Returns: 

560 

561 * (string): Value of the information item, if the item exists. 

562 The empty string, if the item does not exist. 

563 

564 See `os-release file`_ for details about these information items. 

565 """ 

566 return _distro.os_release_attr(attribute) 

567 

568 

569def lsb_release_attr(attribute: str) -> str: 

570 """ 

571 Return a single named information item from the lsb_release command output 

572 data source of the current OS distribution. 

573 

574 Parameters: 

575 

576 * ``attribute`` (string): Key of the information item. 

577 

578 Returns: 

579 

580 * (string): Value of the information item, if the item exists. 

581 The empty string, if the item does not exist. 

582 

583 See `lsb_release command output`_ for details about these information 

584 items. 

585 """ 

586 return _distro.lsb_release_attr(attribute) 

587 

588 

589def distro_release_attr(attribute: str) -> str: 

590 """ 

591 Return a single named information item from the distro release file 

592 data source of the current OS distribution. 

593 

594 Parameters: 

595 

596 * ``attribute`` (string): Key of the information item. 

597 

598 Returns: 

599 

600 * (string): Value of the information item, if the item exists. 

601 The empty string, if the item does not exist. 

602 

603 See `distro release file`_ for details about these information items. 

604 """ 

605 return _distro.distro_release_attr(attribute) 

606 

607 

608def uname_attr(attribute: str) -> str: 

609 """ 

610 Return a single named information item from the distro release file 

611 data source of the current OS distribution. 

612 

613 Parameters: 

614 

615 * ``attribute`` (string): Key of the information item. 

616 

617 Returns: 

618 

619 * (string): Value of the information item, if the item exists. 

620 The empty string, if the item does not exist. 

621 """ 

622 return _distro.uname_attr(attribute) 

623 

624 

625try: 

626 from functools import cached_property 

627except ImportError: 

628 # Python < 3.8 

629 class cached_property: # type: ignore 

630 """A version of @property which caches the value. On access, it calls the 

631 underlying function and sets the value in `__dict__` so future accesses 

632 will not re-call the property. 

633 """ 

634 

635 def __init__(self, f: Callable[[Any], Any]) -> None: 

636 self._fname = f.__name__ 

637 self._f = f 

638 

639 def __get__(self, obj: Any, owner: Type[Any]) -> Any: 

640 assert obj is not None, f"call {self._fname} on an instance" 

641 ret = obj.__dict__[self._fname] = self._f(obj) 

642 return ret 

643 

644 

645class LinuxDistribution: 

646 """ 

647 Provides information about a OS distribution. 

648 

649 This package creates a private module-global instance of this class with 

650 default initialization arguments, that is used by the 

651 `consolidated accessor functions`_ and `single source accessor functions`_. 

652 By using default initialization arguments, that module-global instance 

653 returns data about the current OS distribution (i.e. the distro this 

654 package runs on). 

655 

656 Normally, it is not necessary to create additional instances of this class. 

657 However, in situations where control is needed over the exact data sources 

658 that are used, instances of this class can be created with a specific 

659 distro release file, or a specific os-release file, or without invoking the 

660 lsb_release command. 

661 """ 

662 

663 def __init__( 

664 self, 

665 include_lsb: Optional[bool] = None, 

666 os_release_file: str = "", 

667 distro_release_file: str = "", 

668 include_uname: Optional[bool] = None, 

669 root_dir: Optional[str] = None, 

670 include_oslevel: Optional[bool] = None, 

671 ) -> None: 

672 """ 

673 The initialization method of this class gathers information from the 

674 available data sources, and stores that in private instance attributes. 

675 Subsequent access to the information items uses these private instance 

676 attributes, so that the data sources are read only once. 

677 

678 Parameters: 

679 

680 * ``include_lsb`` (bool): Controls whether the 

681 `lsb_release command output`_ is included as a data source. 

682 

683 If the lsb_release command is not available in the program execution 

684 path, the data source for the lsb_release command will be empty. 

685 

686 * ``os_release_file`` (string): The path name of the 

687 `os-release file`_ that is to be used as a data source. 

688 

689 An empty string (the default) will cause the default path name to 

690 be used (see `os-release file`_ for details). 

691 

692 If the specified or defaulted os-release file does not exist, the 

693 data source for the os-release file will be empty. 

694 

695 * ``distro_release_file`` (string): The path name of the 

696 `distro release file`_ that is to be used as a data source. 

697 

698 An empty string (the default) will cause a default search algorithm 

699 to be used (see `distro release file`_ for details). 

700 

701 If the specified distro release file does not exist, or if no default 

702 distro release file can be found, the data source for the distro 

703 release file will be empty. 

704 

705 * ``include_uname`` (bool): Controls whether uname command output is 

706 included as a data source. If the uname command is not available in 

707 the program execution path the data source for the uname command will 

708 be empty. 

709 

710 * ``root_dir`` (string): The absolute path to the root directory to use 

711 to find distro-related information files. Note that ``include_*`` 

712 parameters must not be enabled in combination with ``root_dir``. 

713 

714 * ``include_oslevel`` (bool): Controls whether (AIX) oslevel command 

715 output is included as a data source. If the oslevel command is not 

716 available in the program execution path the data source will be 

717 empty. 

718 

719 Public instance attributes: 

720 

721 * ``os_release_file`` (string): The path name of the 

722 `os-release file`_ that is actually used as a data source. The 

723 empty string if no distro release file is used as a data source. 

724 

725 * ``distro_release_file`` (string): The path name of the 

726 `distro release file`_ that is actually used as a data source. The 

727 empty string if no distro release file is used as a data source. 

728 

729 * ``include_lsb`` (bool): The result of the ``include_lsb`` parameter. 

730 This controls whether the lsb information will be loaded. 

731 

732 * ``include_uname`` (bool): The result of the ``include_uname`` 

733 parameter. This controls whether the uname information will 

734 be loaded. 

735 

736 * ``include_oslevel`` (bool): The result of the ``include_oslevel`` 

737 parameter. This controls whether (AIX) oslevel information will be 

738 loaded. 

739 

740 * ``root_dir`` (string): The result of the ``root_dir`` parameter. 

741 The absolute path to the root directory to use to find distro-related 

742 information files. 

743 

744 Raises: 

745 

746 * :py:exc:`ValueError`: Initialization parameters combination is not 

747 supported. 

748 

749 * :py:exc:`OSError`: Some I/O issue with an os-release file or distro 

750 release file. 

751 

752 * :py:exc:`UnicodeError`: A data source has unexpected characters or 

753 uses an unexpected encoding. 

754 """ 

755 self.root_dir = root_dir 

756 self.etc_dir = os.path.join(root_dir, "etc") if root_dir else _UNIXCONFDIR 

757 self.usr_lib_dir = ( 

758 os.path.join(root_dir, "usr/lib") if root_dir else _UNIXUSRLIBDIR 

759 ) 

760 

761 if os_release_file: 

762 self.os_release_file = os_release_file 

763 else: 

764 etc_dir_os_release_file = os.path.join(self.etc_dir, _OS_RELEASE_BASENAME) 

765 usr_lib_os_release_file = os.path.join( 

766 self.usr_lib_dir, _OS_RELEASE_BASENAME 

767 ) 

768 

769 # NOTE: The idea is to respect order **and** have it set 

770 # at all times for API backwards compatibility. 

771 if os.path.isfile(etc_dir_os_release_file) or not os.path.isfile( 

772 usr_lib_os_release_file 

773 ): 

774 self.os_release_file = etc_dir_os_release_file 

775 else: 

776 self.os_release_file = usr_lib_os_release_file 

777 

778 self.distro_release_file = distro_release_file or "" # updated later 

779 

780 is_root_dir_defined = root_dir is not None 

781 if is_root_dir_defined and (include_lsb or include_uname or include_oslevel): 

782 raise ValueError( 

783 "Including subprocess data sources from specific root_dir is disallowed" 

784 " to prevent false information" 

785 ) 

786 self.include_lsb = ( 

787 include_lsb if include_lsb is not None else not is_root_dir_defined 

788 ) 

789 self.include_uname = ( 

790 include_uname if include_uname is not None else not is_root_dir_defined 

791 ) 

792 self.include_oslevel = ( 

793 include_oslevel if include_oslevel is not None else not is_root_dir_defined 

794 ) 

795 

796 def __repr__(self) -> str: 

797 """Return repr of all info""" 

798 return ( 

799 "LinuxDistribution(" 

800 "os_release_file={self.os_release_file!r}, " 

801 "distro_release_file={self.distro_release_file!r}, " 

802 "include_lsb={self.include_lsb!r}, " 

803 "include_uname={self.include_uname!r}, " 

804 "include_oslevel={self.include_oslevel!r}, " 

805 "root_dir={self.root_dir!r}, " 

806 "_os_release_info={self._os_release_info!r}, " 

807 "_lsb_release_info={self._lsb_release_info!r}, " 

808 "_distro_release_info={self._distro_release_info!r}, " 

809 "_uname_info={self._uname_info!r}, " 

810 "_oslevel_info={self._oslevel_info!r})".format(self=self) 

811 ) 

812 

813 def linux_distribution( 

814 self, full_distribution_name: bool = True 

815 ) -> Tuple[str, str, str]: 

816 """ 

817 Return information about the OS distribution that is compatible 

818 with Python's :func:`platform.linux_distribution`, supporting a subset 

819 of its parameters. 

820 

821 For details, see :func:`distro.linux_distribution`. 

822 """ 

823 return ( 

824 self.name() if full_distribution_name else self.id(), 

825 self.version(), 

826 self._os_release_info.get("release_codename") or self.codename(), 

827 ) 

828 

829 def id(self) -> str: 

830 """Return the distro ID of the OS distribution, as a string. 

831 

832 For details, see :func:`distro.id`. 

833 """ 

834 

835 def normalize(distro_id: str, table: Dict[str, str]) -> str: 

836 distro_id = distro_id.lower().replace(" ", "_") 

837 return table.get(distro_id, distro_id) 

838 

839 distro_id = self.os_release_attr("id") 

840 if distro_id: 

841 return normalize(distro_id, NORMALIZED_OS_ID) 

842 

843 distro_id = self.lsb_release_attr("distributor_id") 

844 if distro_id: 

845 return normalize(distro_id, NORMALIZED_LSB_ID) 

846 

847 distro_id = self.distro_release_attr("id") 

848 if distro_id: 

849 return normalize(distro_id, NORMALIZED_DISTRO_ID) 

850 

851 distro_id = self.uname_attr("id") 

852 if distro_id: 

853 return normalize(distro_id, NORMALIZED_DISTRO_ID) 

854 

855 return "" 

856 

857 def name(self, pretty: bool = False) -> str: 

858 """ 

859 Return the name of the OS distribution, as a string. 

860 

861 For details, see :func:`distro.name`. 

862 """ 

863 name = ( 

864 self.os_release_attr("name") 

865 or self.lsb_release_attr("distributor_id") 

866 or self.distro_release_attr("name") 

867 or self.uname_attr("name") 

868 ) 

869 if pretty: 

870 name = self.os_release_attr("pretty_name") or self.lsb_release_attr( 

871 "description" 

872 ) 

873 if not name: 

874 name = self.distro_release_attr("name") or self.uname_attr("name") 

875 version = self.version(pretty=True) 

876 if version: 

877 name = f"{name} {version}" 

878 return name or "" 

879 

880 def version(self, pretty: bool = False, best: bool = False) -> str: 

881 """ 

882 Return the version of the OS distribution, as a string. 

883 

884 For details, see :func:`distro.version`. 

885 """ 

886 versions = [ 

887 self.os_release_attr("version_id"), 

888 self.lsb_release_attr("release"), 

889 self.distro_release_attr("version_id"), 

890 self._parse_distro_release_content(self.os_release_attr("pretty_name")).get( 

891 "version_id", "" 

892 ), 

893 self._parse_distro_release_content( 

894 self.lsb_release_attr("description") 

895 ).get("version_id", ""), 

896 self.uname_attr("release"), 

897 ] 

898 if self.uname_attr("id").startswith("aix"): 

899 # On AIX platforms, prefer oslevel command output. 

900 versions.insert(0, self.oslevel_info()) 

901 elif self.id() == "debian" or "debian" in self.like().split(): 

902 # On Debian-like, add debian_version file content to candidates list. 

903 versions.append(self._debian_version) 

904 version = "" 

905 if best: 

906 # This algorithm uses the last version in priority order that has 

907 # the best precision. If the versions are not in conflict, that 

908 # does not matter; otherwise, using the last one instead of the 

909 # first one might be considered a surprise. 

910 for v in versions: 

911 if v.count(".") > version.count(".") or version == "": 

912 version = v 

913 else: 

914 for v in versions: 

915 if v != "": 

916 version = v 

917 break 

918 if pretty and version and self.codename(): 

919 version = f"{version} ({self.codename()})" 

920 return version 

921 

922 def version_parts(self, best: bool = False) -> Tuple[str, str, str]: 

923 """ 

924 Return the version of the OS distribution, as a tuple of version 

925 numbers. 

926 

927 For details, see :func:`distro.version_parts`. 

928 """ 

929 version_str = self.version(best=best) 

930 if version_str: 

931 version_regex = re.compile(r"(\d+)\.?(\d+)?\.?(\d+)?") 

932 matches = version_regex.match(version_str) 

933 if matches: 

934 major, minor, build_number = matches.groups() 

935 return major, minor or "", build_number or "" 

936 return "", "", "" 

937 

938 def major_version(self, best: bool = False) -> str: 

939 """ 

940 Return the major version number of the current distribution. 

941 

942 For details, see :func:`distro.major_version`. 

943 """ 

944 return self.version_parts(best)[0] 

945 

946 def minor_version(self, best: bool = False) -> str: 

947 """ 

948 Return the minor version number of the current distribution. 

949 

950 For details, see :func:`distro.minor_version`. 

951 """ 

952 return self.version_parts(best)[1] 

953 

954 def build_number(self, best: bool = False) -> str: 

955 """ 

956 Return the build number of the current distribution. 

957 

958 For details, see :func:`distro.build_number`. 

959 """ 

960 return self.version_parts(best)[2] 

961 

962 def like(self) -> str: 

963 """ 

964 Return the IDs of distributions that are like the OS distribution. 

965 

966 For details, see :func:`distro.like`. 

967 """ 

968 return self.os_release_attr("id_like") or "" 

969 

970 def codename(self) -> str: 

971 """ 

972 Return the codename of the OS distribution. 

973 

974 For details, see :func:`distro.codename`. 

975 """ 

976 try: 

977 # Handle os_release specially since distros might purposefully set 

978 # this to empty string to have no codename 

979 return self._os_release_info["codename"] 

980 except KeyError: 

981 return ( 

982 self.lsb_release_attr("codename") 

983 or self.distro_release_attr("codename") 

984 or "" 

985 ) 

986 

987 def info(self, pretty: bool = False, best: bool = False) -> InfoDict: 

988 """ 

989 Return certain machine-readable information about the OS 

990 distribution. 

991 

992 For details, see :func:`distro.info`. 

993 """ 

994 return dict( 

995 id=self.id(), 

996 version=self.version(pretty, best), 

997 version_parts=dict( 

998 major=self.major_version(best), 

999 minor=self.minor_version(best), 

1000 build_number=self.build_number(best), 

1001 ), 

1002 like=self.like(), 

1003 codename=self.codename(), 

1004 ) 

1005 

1006 def os_release_info(self) -> Dict[str, str]: 

1007 """ 

1008 Return a dictionary containing key-value pairs for the information 

1009 items from the os-release file data source of the OS distribution. 

1010 

1011 For details, see :func:`distro.os_release_info`. 

1012 """ 

1013 return self._os_release_info 

1014 

1015 def lsb_release_info(self) -> Dict[str, str]: 

1016 """ 

1017 Return a dictionary containing key-value pairs for the information 

1018 items from the lsb_release command data source of the OS 

1019 distribution. 

1020 

1021 For details, see :func:`distro.lsb_release_info`. 

1022 """ 

1023 return self._lsb_release_info 

1024 

1025 def distro_release_info(self) -> Dict[str, str]: 

1026 """ 

1027 Return a dictionary containing key-value pairs for the information 

1028 items from the distro release file data source of the OS 

1029 distribution. 

1030 

1031 For details, see :func:`distro.distro_release_info`. 

1032 """ 

1033 return self._distro_release_info 

1034 

1035 def uname_info(self) -> Dict[str, str]: 

1036 """ 

1037 Return a dictionary containing key-value pairs for the information 

1038 items from the uname command data source of the OS distribution. 

1039 

1040 For details, see :func:`distro.uname_info`. 

1041 """ 

1042 return self._uname_info 

1043 

1044 def oslevel_info(self) -> str: 

1045 """ 

1046 Return AIX' oslevel command output. 

1047 """ 

1048 return self._oslevel_info 

1049 

1050 def os_release_attr(self, attribute: str) -> str: 

1051 """ 

1052 Return a single named information item from the os-release file data 

1053 source of the OS distribution. 

1054 

1055 For details, see :func:`distro.os_release_attr`. 

1056 """ 

1057 return self._os_release_info.get(attribute, "") 

1058 

1059 def lsb_release_attr(self, attribute: str) -> str: 

1060 """ 

1061 Return a single named information item from the lsb_release command 

1062 output data source of the OS distribution. 

1063 

1064 For details, see :func:`distro.lsb_release_attr`. 

1065 """ 

1066 return self._lsb_release_info.get(attribute, "") 

1067 

1068 def distro_release_attr(self, attribute: str) -> str: 

1069 """ 

1070 Return a single named information item from the distro release file 

1071 data source of the OS distribution. 

1072 

1073 For details, see :func:`distro.distro_release_attr`. 

1074 """ 

1075 return self._distro_release_info.get(attribute, "") 

1076 

1077 def uname_attr(self, attribute: str) -> str: 

1078 """ 

1079 Return a single named information item from the uname command 

1080 output data source of the OS distribution. 

1081 

1082 For details, see :func:`distro.uname_attr`. 

1083 """ 

1084 return self._uname_info.get(attribute, "") 

1085 

1086 @cached_property 

1087 def _os_release_info(self) -> Dict[str, str]: 

1088 """ 

1089 Get the information items from the specified os-release file. 

1090 

1091 Returns: 

1092 A dictionary containing all information items. 

1093 """ 

1094 if os.path.isfile(self.os_release_file): 

1095 with open(self.os_release_file, encoding="utf-8") as release_file: