Coverage for /pythoncovmergedfiles/medio/medio/usr/lib/python3.9/pathlib.py: 33%

1import fnmatch 

2import functools 

3import io 

4import ntpath 

5import os 

6import posixpath 

7import re 

8import sys 

9from _collections_abc import Sequence 

10from errno import EINVAL, ENOENT, ENOTDIR, EBADF, ELOOP 

11from operator import attrgetter 

12from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO 

13from urllib.parse import quote_from_bytes as urlquote_from_bytes 

14 

15 

16supports_symlinks = True 

17if os.name == 'nt': 

18 import nt 

19 if sys.getwindowsversion()[:2] >= (6, 0): 

20 from nt import _getfinalpathname 

21 else: 

22 supports_symlinks = False 

23 _getfinalpathname = None 

24else: 

25 nt = None 

26 

27 

28__all__ = [ 

29 "PurePath", "PurePosixPath", "PureWindowsPath", 

30 "Path", "PosixPath", "WindowsPath", 

31 ] 

32 

33# 

34# Internals 

35# 

36 

37# EBADF - guard against macOS `stat` throwing EBADF 

38_IGNORED_ERROS = (ENOENT, ENOTDIR, EBADF, ELOOP) 

39 

40_IGNORED_WINERRORS = ( 

41 21, # ERROR_NOT_READY - drive exists but is not accessible 

42 123, # ERROR_INVALID_NAME - fix for bpo-35306 

43 1921, # ERROR_CANT_RESOLVE_FILENAME - fix for broken symlink pointing to itself 

44) 

45 

46def _ignore_error(exception): 

47 return (getattr(exception, 'errno', None) in _IGNORED_ERROS or 

48 getattr(exception, 'winerror', None) in _IGNORED_WINERRORS) 

49 

50 

51def _is_wildcard_pattern(pat): 

52 # Whether this pattern needs actual matching using fnmatch, or can 

53 # be looked up directly as a file. 

54 return "*" in pat or "?" in pat or "[" in pat 

55 

56 

57class _Flavour(object): 

58 """A flavour implements a particular (platform-specific) set of path 

59 semantics.""" 

60 

61 def __init__(self): 

62 self.join = self.sep.join 

63 

64 def parse_parts(self, parts): 

65 parsed = [] 

66 sep = self.sep 

67 altsep = self.altsep 

68 drv = root = '' 

69 it = reversed(parts) 

70 for part in it: 

71 if not part: 

72 continue 

73 if altsep: 

74 part = part.replace(altsep, sep) 

75 drv, root, rel = self.splitroot(part) 

76 if sep in rel: 

77 for x in reversed(rel.split(sep)): 

78 if x and x != '.': 

79 parsed.append(sys.intern(x)) 

80 else: 

81 if rel and rel != '.': 

82 parsed.append(sys.intern(rel)) 

83 if drv or root: 

84 if not drv: 

85 # If no drive is present, try to find one in the previous 

86 # parts. This makes the result of parsing e.g. 

87 # ("C:", "/", "a") reasonably intuitive. 

88 for part in it: 

89 if not part: 

90 continue 

91 if altsep: 

92 part = part.replace(altsep, sep) 

93 drv = self.splitroot(part)[0] 

94 if drv: 

95 break 

96 break 

97 if drv or root: 

98 parsed.append(drv + root) 

99 parsed.reverse() 

100 return drv, root, parsed 

101 

102 def join_parsed_parts(self, drv, root, parts, drv2, root2, parts2): 

103 """ 

104 Join the two paths represented by the respective 

105 (drive, root, parts) tuples. Return a new (drive, root, parts) tuple. 

106 """ 

107 if root2: 

108 if not drv2 and drv: 

109 return drv, root2, [drv + root2] + parts2[1:] 

110 elif drv2: 

111 if drv2 == drv or self.casefold(drv2) == self.casefold(drv): 

112 # Same drive => second path is relative to the first 

113 return drv, root, parts + parts2[1:] 

114 else: 

115 # Second path is non-anchored (common case) 

116 return drv, root, parts + parts2 

117 return drv2, root2, parts2 

118 

119 

120class _WindowsFlavour(_Flavour): 

121 # Reference for Windows paths can be found at 

122 # http://msdn.microsoft.com/en-us/library/aa365247%28v=vs.85%29.aspx 

123 

124 sep = '\\' 

125 altsep = '/' 

126 has_drv = True 

127 pathmod = ntpath 

128 

129 is_supported = (os.name == 'nt') 

130 

131 drive_letters = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ') 

132 ext_namespace_prefix = '\\\\?\\' 

133 

134 reserved_names = ( 

135 {'CON', 'PRN', 'AUX', 'NUL'} | 

136 {'COM%d' % i for i in range(1, 10)} | 

137 {'LPT%d' % i for i in range(1, 10)} 

138 ) 

139 

140 # Interesting findings about extended paths: 

141 # - '\\?\c:\a', '//?/c:\a' and '//?/c:/a' are all supported 

142 # but '\\?\c:/a' is not 

143 # - extended paths are always absolute; "relative" extended paths will 

144 # fail. 

145 

146 def splitroot(self, part, sep=sep): 

147 first = part[0:1] 

148 second = part[1:2] 

149 if (second == sep and first == sep): 

150 # XXX extended paths should also disable the collapsing of "." 

151 # components (according to MSDN docs). 

152 prefix, part = self._split_extended_path(part) 

153 first = part[0:1] 

154 second = part[1:2] 

155 else: 

156 prefix = '' 

157 third = part[2:3] 

158 if (second == sep and first == sep and third != sep): 

159 # is a UNC path: 

160 # vvvvvvvvvvvvvvvvvvvvv root 

161 # \\machine\mountpoint\directory\etc\... 

162 # directory ^^^^^^^^^^^^^^ 

163 index = part.find(sep, 2) 

164 if index != -1: 

165 index2 = part.find(sep, index + 1) 

166 # a UNC path can't have two slashes in a row 

167 # (after the initial two) 

168 if index2 != index + 1: 

169 if index2 == -1: 

170 index2 = len(part) 

171 if prefix: 

172 return prefix + part[1:index2], sep, part[index2+1:] 

173 else: 

174 return part[:index2], sep, part[index2+1:] 

175 drv = root = '' 

176 if second == ':' and first in self.drive_letters: 

177 drv = part[:2] 

178 part = part[2:] 

179 first = third 

180 if first == sep: 

181 root = first 

182 part = part.lstrip(sep) 

183 return prefix + drv, root, part 

184 

185 def casefold(self, s): 

186 return s.lower() 

187 

188 def casefold_parts(self, parts): 

189 return [p.lower() for p in parts] 

190 

191 def compile_pattern(self, pattern): 

192 return re.compile(fnmatch.translate(pattern), re.IGNORECASE).fullmatch 

193 

194 def resolve(self, path, strict=False): 

195 s = str(path) 

196 if not s: 

197 return os.getcwd() 

198 previous_s = None 

199 if _getfinalpathname is not None: 

200 if strict: 

201 return self._ext_to_normal(_getfinalpathname(s)) 

202 else: 

203 tail_parts = [] # End of the path after the first one not found 

204 while True: 

205 try: 

206 s = self._ext_to_normal(_getfinalpathname(s)) 

207 except FileNotFoundError: 

208 previous_s = s 

209 s, tail = os.path.split(s) 

210 tail_parts.append(tail) 

211 if previous_s == s: 

212 return path 

213 else: 

214 return os.path.join(s, *reversed(tail_parts)) 

215 # Means fallback on absolute 

216 return None 

217 

218 def _split_extended_path(self, s, ext_prefix=ext_namespace_prefix): 

219 prefix = '' 

220 if s.startswith(ext_prefix): 

221 prefix = s[:4] 

222 s = s[4:] 

223 if s.startswith('UNC\\'): 

224 prefix += s[:3] 

225 s = '\\' + s[3:] 

226 return prefix, s 

227 

228 def _ext_to_normal(self, s): 

229 # Turn back an extended path into a normal DOS-like path 

230 return self._split_extended_path(s)[1] 

231 

232 def is_reserved(self, parts): 

233 # NOTE: the rules for reserved names seem somewhat complicated 

234 # (e.g. r"..\NUL" is reserved but not r"foo\NUL"). 

235 # We err on the side of caution and return True for paths which are 

236 # not considered reserved by Windows. 

237 if not parts: 

238 return False 

239 if parts[0].startswith('\\\\'): 

240 # UNC paths are never reserved 

241 return False 

242 return parts[-1].partition('.')[0].upper() in self.reserved_names 

243 

244 def make_uri(self, path): 

245 # Under Windows, file URIs use the UTF-8 encoding. 

246 drive = path.drive 

247 if len(drive) == 2 and drive[1] == ':': 

248 # It's a path on a local drive => 'file:///c:/a/b' 

249 rest = path.as_posix()[2:].lstrip('/') 

250 return 'file:///%s/%s' % ( 

251 drive, urlquote_from_bytes(rest.encode('utf-8'))) 

252 else: 

253 # It's a path on a network drive => 'file://host/share/a/b' 

254 return 'file:' + urlquote_from_bytes(path.as_posix().encode('utf-8')) 

255 

256 def gethomedir(self, username): 

257 if 'USERPROFILE' in os.environ: 

258 userhome = os.environ['USERPROFILE'] 

259 elif 'HOMEPATH' in os.environ: 

260 try: 

261 drv = os.environ['HOMEDRIVE'] 

262 except KeyError: 

263 drv = '' 

264 userhome = drv + os.environ['HOMEPATH'] 

265 else: 

266 raise RuntimeError("Can't determine home directory") 

267 

268 if username: 

269 # Try to guess user home directory. By default all users 

270 # directories are located in the same place and are named by 

271 # corresponding usernames. If current user home directory points 

272 # to nonstandard place, this guess is likely wrong. 

273 if os.environ['USERNAME'] != username: 

274 drv, root, parts = self.parse_parts((userhome,)) 

275 if parts[-1] != os.environ['USERNAME']: 

276 raise RuntimeError("Can't determine home directory " 

277 "for %r" % username) 

278 parts[-1] = username 

279 if drv or root: 

280 userhome = drv + root + self.join(parts[1:]) 

281 else: 

282 userhome = self.join(parts) 

283 return userhome 

284 

285class _PosixFlavour(_Flavour): 

286 sep = '/' 

287 altsep = '' 

288 has_drv = False 

289 pathmod = posixpath 

290 

291 is_supported = (os.name != 'nt') 

292 

293 def splitroot(self, part, sep=sep): 

294 if part and part[0] == sep: 

295 stripped_part = part.lstrip(sep) 

296 # According to POSIX path resolution: 

297 # http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap04.html#tag_04_11 

298 # "A pathname that begins with two successive slashes may be 

299 # interpreted in an implementation-defined manner, although more 

300 # than two leading slashes shall be treated as a single slash". 

301 if len(part) - len(stripped_part) == 2: 

302 return '', sep * 2, stripped_part 

303 else: 

304 return '', sep, stripped_part 

305 else: 

306 return '', '', part 

307 

308 def casefold(self, s): 

309 return s 

310 

311 def casefold_parts(self, parts): 

312 return parts 

313 

314 def compile_pattern(self, pattern): 

315 return re.compile(fnmatch.translate(pattern)).fullmatch 

316 

317 def resolve(self, path, strict=False): 

318 sep = self.sep 

319 accessor = path._accessor 

320 seen = {} 

321 def _resolve(path, rest): 

322 if rest.startswith(sep): 

323 path = '' 

324 

325 for name in rest.split(sep): 

326 if not name or name == '.': 

327 # current dir 

328 continue 

329 if name == '..': 

330 # parent dir 

331 path, _, _ = path.rpartition(sep) 

332 continue 

333 if path.endswith(sep): 

334 newpath = path + name 

335 else: 

336 newpath = path + sep + name 

337 if newpath in seen: 

338 # Already seen this path 

339 path = seen[newpath] 

340 if path is not None: 

341 # use cached value 

342 continue 

343 # The symlink is not resolved, so we must have a symlink loop. 

344 raise RuntimeError("Symlink loop from %r" % newpath) 

345 # Resolve the symbolic link 

346 try: 

347 target = accessor.readlink(newpath) 

348 except OSError as e: 

349 if e.errno != EINVAL and strict: 

350 raise 

351 # Not a symlink, or non-strict mode. We just leave the path 

352 # untouched. 

353 path = newpath 

354 else: 

355 seen[newpath] = None # not resolved symlink 

356 path = _resolve(path, target) 

357 seen[newpath] = path # resolved symlink 

358 

359 return path 

360 # NOTE: according to POSIX, getcwd() cannot contain path components 

361 # which are symlinks. 

362 base = '' if path.is_absolute() else os.getcwd() 

363 return _resolve(base, str(path)) or sep 

364 

365 def is_reserved(self, parts): 

366 return False 

367 

368 def make_uri(self, path): 

369 # We represent the path using the local filesystem encoding, 

370 # for portability to other applications. 

371 bpath = bytes(path) 

372 return 'file://' + urlquote_from_bytes(bpath) 

373 

374 def gethomedir(self, username): 

375 if not username: 

376 try: 

377 return os.environ['HOME'] 

378 except KeyError: 

379 import pwd 

380 return pwd.getpwuid(os.getuid()).pw_dir 

381 else: 

382 import pwd 

383 try: 

384 return pwd.getpwnam(username).pw_dir 

385 except KeyError: 

386 raise RuntimeError("Can't determine home directory " 

387 "for %r" % username) 

388 

389 

390_windows_flavour = _WindowsFlavour() 

391_posix_flavour = _PosixFlavour() 

392 

393 

394class _Accessor: 

395 """An accessor implements a particular (system-specific or not) way of 

396 accessing paths on the filesystem.""" 

397 

398 

399class _NormalAccessor(_Accessor): 

400 

401 stat = os.stat 

402 

403 lstat = os.lstat 

404 

405 open = os.open 

406 

407 listdir = os.listdir 

408 

409 scandir = os.scandir 

410 

411 chmod = os.chmod 

412 

413 if hasattr(os, "lchmod"): 

414 lchmod = os.lchmod 

415 else: 

416 def lchmod(self, pathobj, mode): 

417 raise NotImplementedError("lchmod() not available on this system") 

418 

419 mkdir = os.mkdir 

420 

421 unlink = os.unlink 

422 

423 if hasattr(os, "link"): 

424 link_to = os.link 

425 else: 

426 @staticmethod 

427 def link_to(self, target): 

428 raise NotImplementedError("os.link() not available on this system") 

429 

430 rmdir = os.rmdir 

431 

432 rename = os.rename 

433 

434 replace = os.replace 

435 

436 if nt: 

437 if supports_symlinks: 

438 symlink = os.symlink 

439 else: 

440 def symlink(a, b, target_is_directory): 

441 raise NotImplementedError("symlink() not available on this system") 

442 else: 

443 # Under POSIX, os.symlink() takes two args 

444 @staticmethod 

445 def symlink(a, b, target_is_directory): 

446 return os.symlink(a, b) 

447 

448 utime = os.utime 

449 

450 # Helper for resolve() 

451 def readlink(self, path): 

452 return os.readlink(path) 

453 

454 def owner(self, path): 

455 try: 

456 import pwd 

457 return pwd.getpwuid(self.stat(path).st_uid).pw_name 

458 except ImportError: 

459 raise NotImplementedError("Path.owner() is unsupported on this system") 

460 

461 def group(self, path): 

462 try: 

463 import grp 

464 return grp.getgrgid(self.stat(path).st_gid).gr_name 

465 except ImportError: 

466 raise NotImplementedError("Path.group() is unsupported on this system") 

467 

468 

469_normal_accessor = _NormalAccessor() 

470 

471 

472# 

473# Globbing helpers 

474# 

475 

476def _make_selector(pattern_parts, flavour): 

477 pat = pattern_parts[0] 

478 child_parts = pattern_parts[1:] 

479 if pat == '**': 

480 cls = _RecursiveWildcardSelector 

481 elif '**' in pat: 

482 raise ValueError("Invalid pattern: '**' can only be an entire path component") 

483 elif _is_wildcard_pattern(pat): 

484 cls = _WildcardSelector 

485 else: 

486 cls = _PreciseSelector 

487 return cls(pat, child_parts, flavour) 

488 

489if hasattr(functools, "lru_cache"): 

490 _make_selector = functools.lru_cache()(_make_selector) 

491 

492 

493class _Selector: 

494 """A selector matches a specific glob pattern part against the children 

495 of a given path.""" 

496 

497 def __init__(self, child_parts, flavour): 

498 self.child_parts = child_parts 

499 if child_parts: 

500 self.successor = _make_selector(child_parts, flavour) 

501 self.dironly = True 

502 else: 

503 self.successor = _TerminatingSelector() 

504 self.dironly = False 

505 

506 def select_from(self, parent_path): 

507 """Iterate over all child paths of `parent_path` matched by this 

508 selector. This can contain parent_path itself.""" 

509 path_cls = type(parent_path) 

510 is_dir = path_cls.is_dir 

511 exists = path_cls.exists 

512 scandir = parent_path._accessor.scandir 

513 if not is_dir(parent_path): 

514 return iter([]) 

515 return self._select_from(parent_path, is_dir, exists, scandir) 

516 

517 

518class _TerminatingSelector: 

519 

520 def _select_from(self, parent_path, is_dir, exists, scandir): 

521 yield parent_path 

522 

523 

524class _PreciseSelector(_Selector): 

525 

526 def __init__(self, name, child_parts, flavour): 

527 self.name = name 

528 _Selector.__init__(self, child_parts, flavour) 

529 

530 def _select_from(self, parent_path, is_dir, exists, scandir): 

531 try: 

532 path = parent_path._make_child_relpath(self.name) 

533 if (is_dir if self.dironly else exists)(path): 

534 for p in self.successor._select_from(path, is_dir, exists, scandir): 

535 yield p 

536 except PermissionError: 

537 return 

538 

539 

540class _WildcardSelector(_Selector): 

541 

542 def __init__(self, pat, child_parts, flavour): 

543 self.match = flavour.compile_pattern(pat) 

544 _Selector.__init__(self, child_parts, flavour) 

545 

546 def _select_from(self, parent_path, is_dir, exists, scandir): 

547 try: 

548 with scandir(parent_path) as scandir_it: 

549 entries = list(scandir_it) 

550 for entry in entries: 

551 if self.dironly: 

552 try: 

553 # "entry.is_dir()" can raise PermissionError 

554 # in some cases (see bpo-38894), which is not 

555 # among the errors ignored by _ignore_error() 

556 if not entry.is_dir(): 

557 continue 

558 except OSError as e: 

559 if not _ignore_error(e): 

560 raise 

561 continue 

562 name = entry.name 

563 if self.match(name): 

564 path = parent_path._make_child_relpath(name) 

565 for p in self.successor._select_from(path, is_dir, exists, scandir): 

566 yield p 

567 except PermissionError: 

568 return 

569 

570 

571class _RecursiveWildcardSelector(_Selector): 

572 

573 def __init__(self, pat, child_parts, flavour): 

574 _Selector.__init__(self, child_parts, flavour) 

575 

576 def _iterate_directories(self, parent_path, is_dir, scandir): 

577 yield parent_path 

578 try: 

579 with scandir(parent_path) as scandir_it: 

580 entries = list(scandir_it) 

581 for entry in entries: 

582 entry_is_dir = False 

583 try: 

584 entry_is_dir = entry.is_dir() 

585 except OSError as e: 

586 if not _ignore_error(e): 

587 raise 

588 if entry_is_dir and not entry.is_symlink(): 

589 path = parent_path._make_child_relpath(entry.name) 

590 for p in self._iterate_directories(path, is_dir, scandir): 

591 yield p 

592 except PermissionError: 

593 return 

594 

595 def _select_from(self, parent_path, is_dir, exists, scandir): 

596 try: 

597 yielded = set() 

598 try: 

599 successor_select = self.successor._select_from 

600 for starting_point in self._iterate_directories(parent_path, is_dir, scandir): 

601 for p in successor_select(starting_point, is_dir, exists, scandir): 

602 if p not in yielded: 

603 yield p 

604 yielded.add(p) 

605 finally: 

606 yielded.clear() 

607 except PermissionError: 

608 return 

609 

610 

611# 

612# Public API 

613# 

614 

615class _PathParents(Sequence): 

616 """This object provides sequence-like access to the logical ancestors 

617 of a path. Don't try to construct it yourself.""" 

618 __slots__ = ('_pathcls', '_drv', '_root', '_parts') 

619 

620 def __init__(self, path): 

621 # We don't store the instance to avoid reference cycles 

622 self._pathcls = type(path) 

623 self._drv = path._drv 

624 self._root = path._root 

625 self._parts = path._parts 

626 

627 def __len__(self): 

628 if self._drv or self._root: 

629 return len(self._parts) - 1 

630 else: 

631 return len(self._parts) 

632 

633 def __getitem__(self, idx): 

634 if idx < 0 or idx >= len(self): 

635 raise IndexError(idx) 

636 return self._pathcls._from_parsed_parts(self._drv, self._root, 

637 self._parts[:-idx - 1]) 

638 

639 def __repr__(self): 

640 return "<{}.parents>".format(self._pathcls.__name__) 

641 

642 

643class PurePath(object): 

644 """Base class for manipulating paths without I/O. 

645 

646 PurePath represents a filesystem path and offers operations which 

647 don't imply any actual filesystem I/O. Depending on your system, 

648 instantiating a PurePath will return either a PurePosixPath or a 

649 PureWindowsPath object. You can also instantiate either of these classes 

650 directly, regardless of your system. 

651 """ 

652 __slots__ = ( 

653 '_drv', '_root', '_parts', 

654 '_str', '_hash', '_pparts', '_cached_cparts', 

655 ) 

656 

657 def __new__(cls, *args): 

658 """Construct a PurePath from one or several strings and or existing 

659 PurePath objects. The strings and path objects are combined so as 

660 to yield a canonicalized path, which is incorporated into the 

661 new PurePath object. 

662 """ 

663 if cls is PurePath: 

664 cls = PureWindowsPath if os.name == 'nt' else PurePosixPath 

665 return cls._from_parts(args) 

666 

667 def __reduce__(self): 

668 # Using the parts tuple helps share interned path parts 

669 # when pickling related paths. 

670 return (self.__class__, tuple(self._parts)) 

671 

672 @classmethod 

673 def _parse_args(cls, args): 

674 # This is useful when you don't want to create an instance, just 

675 # canonicalize some constructor arguments. 

676 parts = [] 

677 for a in args: 

678 if isinstance(a, PurePath): 

679 parts += a._parts 

680 else: 

681 a = os.fspath(a) 

682 if isinstance(a, str): 

683 # Force-cast str subclasses to str (issue #21127) 

684 parts.append(str(a)) 

685 else: 

686 raise TypeError( 

687 "argument should be a str object or an os.PathLike " 

688 "object returning str, not %r" 

689 % type(a)) 

690 return cls._flavour.parse_parts(parts) 

691 

692 @classmethod 

693 def _from_parts(cls, args, init=True): 

694 # We need to call _parse_args on the instance, so as to get the 

695 # right flavour. 

696 self = object.__new__(cls) 

697 drv, root, parts = self._parse_args(args) 

698 self._drv = drv 

699 self._root = root 

700 self._parts = parts 

701 if init: 

702 self._init() 

703 return self 

704 

705 @classmethod 

706 def _from_parsed_parts(cls, drv, root, parts, init=True): 

707 self = object.__new__(cls) 

708 self._drv = drv 

709 self._root = root 

710 self._parts = parts 

711 if init: 

712 self._init() 

713 return self 

714 

715 @classmethod 

716 def _format_parsed_parts(cls, drv, root, parts): 

717 if drv or root: 

718 return drv + root + cls._flavour.join(parts[1:]) 

719 else: 

720 return cls._flavour.join(parts) 

721 

722 def _init(self): 

723 # Overridden in concrete Path 

724 pass 

725 

726 def _make_child(self, args): 

727 drv, root, parts = self._parse_args(args) 

728 drv, root, parts = self._flavour.join_parsed_parts( 

729 self._drv, self._root, self._parts, drv, root, parts) 

730 return self._from_parsed_parts(drv, root, parts) 

731 

732 def __str__(self): 

733 """Return the string representation of the path, suitable for 

734 passing to system calls.""" 

735 try: 

736 return self._str 

737 except AttributeError: 

738 self._str = self._format_parsed_parts(self._drv, self._root, 

739 self._parts) or '.' 

740 return self._str 

741 

742 def __fspath__(self): 

743 return str(self) 

744 

745 def as_posix(self): 

746 """Return the string representation of the path with forward (/) 

747 slashes.""" 

748 f = self._flavour 

749 return str(self).replace(f.sep, '/') 

750 

751 def __bytes__(self): 

752 """Return the bytes representation of the path. This is only 

753 recommended to use under Unix.""" 

754 return os.fsencode(self) 

755 

756 def __repr__(self): 

757 return "{}({!r})".format(self.__class__.__name__, self.as_posix()) 

758 

759 def as_uri(self): 

760 """Return the path as a 'file' URI.""" 

761 if not self.is_absolute(): 

762 raise ValueError("relative path can't be expressed as a file URI") 

763 return self._flavour.make_uri(self) 

764 

765 @property 

766 def _cparts(self): 

767 # Cached casefolded parts, for hashing and comparison 

768 try: 

769 return self._cached_cparts 

770 except AttributeError: 

771 self._cached_cparts = self._flavour.casefold_parts(self._parts) 

772 return self._cached_cparts 

773 

774 def __eq__(self, other): 

775 if not isinstance(other, PurePath): 

776 return NotImplemented 

777 return self._cparts == other._cparts and self._flavour is other._flavour 

778 

779 def __hash__(self): 

780 try: 

781 return self._hash 

782 except AttributeError: 

783 self._hash = hash(tuple(self._cparts)) 

784 return self._hash 

785 

786 def __lt__(self, other): 

787 if not isinstance(other, PurePath) or self._flavour is not other._flavour: 

788 return NotImplemented 

789 return self._cparts < other._cparts 

790 

791 def __le__(self, other): 

792 if not isinstance(other, PurePath) or self._flavour is not other._flavour: 

793 return NotImplemented 

794 return self._cparts <= other._cparts 

795 

796 def __gt__(self, other): 

797 if not isinstance(other, PurePath) or self._flavour is not other._flavour: 

798 return NotImplemented 

799 return self._cparts > other._cparts 

800 

801 def __ge__(self, other): 

802 if not isinstance(other, PurePath) or self._flavour is not other._flavour: 

803 return NotImplemented 

804 return self._cparts >= other._cparts 

805 

806 def __class_getitem__(cls, type): 

807 return cls 

808 

809 drive = property(attrgetter('_drv'), 

810 doc="""The drive prefix (letter or UNC path), if any.""") 

811 

812 root = property(attrgetter('_root'), 

813 doc="""The root of the path, if any.""") 

814 

815 @property 

816 def anchor(self): 

817 """The concatenation of the drive and root, or ''.""" 

818 anchor = self._drv + self._root 

819 return anchor 

820 

821 @property 

822 def name(self): 

823 """The final path component, if any.""" 

824 parts = self._parts 

825 if len(parts) == (1 if (self._drv or self._root) else 0):