928: class Path(PurePath):

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

134:     pathmod = ntpath

253:     pathmod = posixpath

565: class PurePath(object):

844:     def joinpath(self, *args):

915: class PurePosixPath(PurePath):

920: class PureWindowsPath(PurePath):

952:     def _make_child_relpath(self, part):

1275: class PosixPath(Path, PurePosixPath):

1278: class WindowsPath(Path, PureWindowsPath):

537: class _PathParents(Sequence):

40:         _getfinalpathname = None

45:     "Path", "PosixPath", "WindowsPath",

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

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

122:             # Second path is non-anchored (common case)

162:             prefix, part = self._split_extended_path(part)

169:             # is a UNC path:

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

201:     def resolve(self, path):

202:         s = str(path)

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

222:         return self._split_extended_path(s)[1]

236:     def make_uri(self, path):

238:         drive = path.drive

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

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

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

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

260:             # According to POSIX path resolution:

278:     def resolve(self, path):

280:         accessor = path._accessor

282:         def _resolve(path, rest):

284:                 path = ''

292:                     path, _, _ = path.rpartition(sep)

294:                 newpath = path + sep + name

296:                     # Already seen this path

297:                     path = seen[newpath]

298:                     if path is not None:

310:                     path = newpath

313:                     path = _resolve(path, target)

314:                     seen[newpath] = path # resolved symlink

316:             return path

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

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

320:         return _resolve(base, str(path)) or sep

325:     def make_uri(self, path):

326:         # We represent the path using the local filesystem encoding,

328:         bpath = bytes(path)

397:     def readlink(self, path):

398:         return os.readlink(path)

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

446:     of a given path."""

455:     def select_from(self, parent_path):

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

457:         selector.  This can contain parent_path itself."""

458:         path_cls = type(parent_path)

459:         is_dir = path_cls.is_dir

460:         exists = path_cls.exists

461:         listdir = parent_path._accessor.listdir

462:         return self._select_from(parent_path, is_dir, exists, listdir)

467:     def _select_from(self, parent_path, is_dir, exists, listdir):

468:         yield parent_path

477:     def _select_from(self, parent_path, is_dir, exists, listdir):

478:         if not is_dir(parent_path):

480:         path = parent_path._make_child_relpath(self.name)

481:         if exists(path):

482:             for p in self.successor._select_from(path, is_dir, exists, listdir):

492:     def _select_from(self, parent_path, is_dir, exists, listdir):

493:         if not is_dir(parent_path):

495:         cf = parent_path._flavour.casefold

496:         for name in listdir(parent_path):

499:                 path = parent_path._make_child_relpath(name)

500:                 for p in self.successor._select_from(path, is_dir, exists, listdir):

509:     def _iterate_directories(self, parent_path, is_dir, listdir):

510:         yield parent_path

511:         for name in listdir(parent_path):

512:             path = parent_path._make_child_relpath(name)

513:             if is_dir(path):

514:                 for p in self._iterate_directories(path, is_dir, listdir):

517:     def _select_from(self, parent_path, is_dir, exists, listdir):

518:         if not is_dir(parent_path):

524:                 for starting_point in self._iterate_directories(parent_path, is_dir, listdir):

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

542:     def __init__(self, path):

544:         self._pathcls = type(path)

545:         self._drv = path._drv

546:         self._root = path._root

547:         self._parts = path._parts

566:     """PurePath represents a filesystem path and offers operations which

579:         PurePath objects.  The strings and path objects are combined so as

580:         to yield a canonicalized path, which is incorporated into the

588:         # Using the parts tuple helps share interned path parts

604:                     "argument should be a path or str object, not %r"

639:         # Overriden in concrete Path

649:         """Return the string representation of the path, suitable for

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

665:         """Return the bytes representation of the path.  This is only

675:         """Return the path as a 'file' URI."""

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

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

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

738:         """The final path component, if any."""

765:         """The final path component, minus its last suffix."""

774:         """Return a new path with the file name changed."""

781:         """Return a new path with the file suffix changed (or added, if none)."""

801:         """Return the relative path to another path identified by the passed

803:         a subpath of the other path), raise ValueError.

807:         #   Path('c:/').relative_to('c:')  gives Path('/')

808:         #   Path('c:/').relative_to('/')   raise ValueError

835:         components in the filesystem path."""

845:         """Combine this path with one or several arguments, and return a

846:         new path representing either a subpath (if all arguments are relative

847:         paths) or a totally different path (if one of the arguments is

864:         """The logical parent of the path."""

874:         """A sequence of this path's logical parents."""

878:         """True if the path is absolute (has both a root and, if applicable,

885:         """Return True if the path contains one of the special names reserved

889:     def match(self, path_pattern):

891:         Return True if this path matches the given pattern.

894:         path_pattern = cf(path_pattern)

895:         drv, root, pat_parts = self._flavour.parse_parts((path_pattern,))

934:         if cls is Path:

954:         # a single part relative to this path.

964:         Open the file pointed by this path and return a file descriptor,

973:         """Return a new path pointing to the current working directory

984:                 # Yielding a path object for these makes little sense

1013:         """Return an absolute version of this path.  This function works

1014:         even if the path doesn't point to anything.

1017:         Use resolve() to get the canonical path to a file.

1030:         Make the path absolute, resolving all symlinks on the way and also

1037:             # the path doesn't exist or is forbidden

1040:         # Now we have no symlinks in the path, it's safe to normalize it.

1048:         Return the result of the stat() system call on this path, like

1070:         Open the file pointed by this path and return a file object, as

1115:         Change the permissions of the path, like os.chmod().

1121:         Like chmod(), except if the path points to a symlink, the symlink's

1129:         If the path is a directory, use rmdir() instead.

1141:         Like stat(), except if the path points to a symlink, the symlink's

1148:         Rename this path to the given path.

1154:         Rename this path to the given path, clobbering the existing

1164:         Make this path a symlink pointing to the given path.

1173:         Whether this path exists.

1185:         Whether this path is a directory.

1192:             # Path doesn't exist or is a broken symlink

1198:         Whether this path is a regular file (also True for symlinks pointing

1206:             # Path doesn't exist or is a broken symlink

1212:         Whether this path is a symbolic link.

1219:             # Path doesn't exist

1224:         Whether this path is a block device.

1231:             # Path doesn't exist or is a broken symlink

1237:         Whether this path is a character device.

1244:             # Path doesn't exist or is a broken symlink

1250:         Whether this path is a FIFO.

1257:             # Path doesn't exist or is a broken symlink

1263:         Whether this path is a socket.

1270:             # Path doesn't exist or is a broken symlink

4: import ntpath

6: import posixpath

44:     "PurePath", "PurePosixPath", "PureWindowsPath",

111:         Join the two paths represented by the respective

128:     # Reference for Windows paths can be found at

150:     # Interesting findings about extended paths:

153:     # - extended paths are always absolute; "relative" extended paths will

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

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

232:             # UNC paths are never reserved

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

295:                 if newpath in seen:

302:                     raise RuntimeError("Symlink loop from %r" % newpath)

305:                     target = accessor.readlink(newpath)

312:                     seen[newpath] = None # not resolved symlink

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

338:     accessing paths on the filesystem."""

345:         def wrapped(pathobj, *args):

346:             return strfunc(str(pathobj), *args)

351:         def wrapped(pathobjA, pathobjB, *args):

352:             return strfunc(str(pathobjA), str(pathobjB), *args)

368:         def lchmod(self, pathobj, mode):

540:     __slots__ = ('_pathcls', '_drv', '_root', '_parts')

558:         return self._pathcls._from_parsed_parts(self._drv, self._root,

562:         return "<{0}.parents>".format(self._pathcls.__name__)

568:     instantiating a PurePath will return either a PurePosixPath or a

569:     PureWindowsPath object.  You can also instantiate either of these classes

578:         """Construct a PurePath from one or several strings and or existing

581:         new PurePath object.

583:         if cls is PurePath:

584:             cls = PureWindowsPath if os.name == 'nt' else PurePosixPath

589:         # when pickling related paths.

598:             if isinstance(a, PurePath):

690:         if not isinstance(other, PurePath):

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

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

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

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

875:         return _PathParents(self)

935:             cls = WindowsPath if os.name == 'nt' else PosixPath

980:         result for the special paths '.' and '..'.

986:             yield self._make_child_relpath(name)

1041:         normed = self._flavour.pathmod.normpath(s)

1193:             # (see https://bitbucket.org/pitrou/pathlib/issue/12/)

1207:             # (see https://bitbucket.org/pitrou/pathlib/issue/12/)

1232:             # (see https://bitbucket.org/pitrou/pathlib/issue/12/)

1245:             # (see https://bitbucket.org/pitrou/pathlib/issue/12/)

1258:             # (see https://bitbucket.org/pitrou/pathlib/issue/12/)

1271:             # (see https://bitbucket.org/pitrou/pathlib/issue/12/)

37:         from nt import _getfinalpathname

205:         if _getfinalpathname is not None:

206:             return self._ext_to_normal(_getfinalpathname(s))

1023:         # use nt._getfullpathname())

419:     path: &'a [u8],

1248: impl ToOwned for Path {

1308: pub struct Path {

1323: impl Path {

1780: impl AsRef<OsStr> for Path {

1786: impl fmt::Debug for Path {

1799:     path: &'a Path,

1814: impl cmp::PartialEq for Path {

1820: impl Hash for Path {

1828: impl cmp::Eq for Path {}

1830: impl cmp::PartialOrd for Path {

1836: impl cmp::Ord for Path {

1842: impl AsRef<Path> for Path {

1890: impl<'a> IntoIterator for &'a Path {

522:     pub fn as_path(&self) -> &'a Path {

653:     pub fn as_path(&self) -> &'a Path {

876:     pub fn as_path(&self) -> &Path {

1015:     pub fn into_boxed_path(self) -> Box<Path> {

848: pub struct PathBuf {

852: impl PathBuf {

1077: impl From<Box<Path>> for PathBuf {

1103: impl<T: ?Sized + AsRef<OsStr>> From<&T> for PathBuf {

1109: impl From<OsString> for PathBuf {

1127: impl From<String> for PathBuf {

1136: impl FromStr for PathBuf {

1144: impl<P: AsRef<Path>> iter::FromIterator<P> for PathBuf {

1152: impl<P: AsRef<Path>> iter::Extend<P> for PathBuf {

1158: impl fmt::Debug for PathBuf {

1164: impl ops::Deref for PathBuf {

1172: impl Borrow<Path> for PathBuf {

1178: impl Default for PathBuf {

1205: impl<'a> From<Cow<'a, Path>> for PathBuf {

1258: impl cmp::PartialEq for PathBuf {

1264: impl Hash for PathBuf {

1270: impl cmp::Eq for PathBuf {}

1272: impl cmp::PartialOrd for PathBuf {

1278: impl cmp::Ord for PathBuf {

1284: impl AsRef<OsStr> for PathBuf {

1878: impl AsRef<Path> for PathBuf {

1884: impl<'a> IntoIterator for &'a PathBuf {

1377:     pub fn to_path_buf(&self) -> PathBuf {

1773:     pub fn into_path_buf(self: Box<Path>) -> PathBuf {

29: //! Cross-platform path manipulation.

31: //! This module provides two types, [`PathBuf`] and [`Path`][`Path`] (akin to [`String`]

34: //! on strings according to the local platform's path syntax.

37: //! returned by the [`components`] method on [`Path`]. [`Component`]s roughly

38: //! correspond to the substrings between path separators (`/` or `\`). You can

39: //! reconstruct an equivalent path from components with the [`push`] method on

49: use crate::sys::path::{is_sep_byte, is_verbatim_sep, MAIN_SEP_STR, parse_prefix};

76: /// Windows path prefixes, e.g., `C:` or `\\server\share`.

78: /// Windows uses a variety of path prefix styles, including references to drive

80: /// others. In addition, some path prefixes are "verbatim" (i.e., prefixed with

182: /// Determines whether the character is one of the permitted path

189: /// The primary separator of path components for the current platform.

192: pub const MAIN_SEPARATOR: char = crate::sys::path::MAIN_SEP;

232:     let path = if let Some(p) = prefix {

237:     !path.is_empty() && is_sep_byte(path[0])

269: /// front and back of the path each keep track of what parts of the path have

272: /// Going front to back, a path is made up of a prefix, a starting

282: /// A structure wrapping a Windows path prefix as well as its unparsed string

346: /// A single component of a path.

348: /// A `Component` roughly corresponds to a substring between path separators

352: /// created by the [`components`][`Path::components`] method on [`Path`].

357:     /// A Windows path prefix, e.g., `C:` or `\\server\share`.

369:     /// It represents a separator that designates that a path starts from root.

394:             Component::Normal(path) => path,

405: impl AsRef<Path> for Component<'_> {

406:     fn as_ref(&self) -> &Path {

411: /// An iterator over the [`Component`]s of a [`Path`].

413: /// This `struct` is created by the [`components`] method on [`Path`].

418:     // The path left to parse components from

424:     // true if path *physically* has a root separator; for most Windows

435: /// An iterator over the [`Component`]s of a [`Path`], as [`OsStr`] slices.

437: /// This `struct` is created by the [`iter`] method on [`Path`].

441: /// [`iter`]: struct.Path.html#method.iter

443: /// [`Path`]: struct.Path.html

451:         struct DebugHelper<'a>(&'a Path);

462:             .field(&DebugHelper(self.as_path()))

489:     // Given the iteration so far, how much of the pre-State::Body path is left?

520:     /// Extracts a slice corresponding to the portion of the path remaining for iteration.

530:         unsafe { Path::from_u8_slice(comps.path) }

533:     /// Is the *original* path rooted?

546:     /// Should the normalized path include a leading . ?

551:         let mut iter = self.path[self.prefix_len()..].iter();

559:     // parse a given byte sequence into the corresponding path component

564:                           // the beginning of a path, which is treated

576:         let (extra, comp) = match self.path.iter().position(|b| self.is_sep_byte(*b)) {

577:             None => (0, self.path),

578:             Some(i) => (1, &self.path[..i]),

588:         let (extra, comp) = match self.path[start..].iter().rposition(|b| self.is_sep_byte(*b)) {

589:             None => (0, &self.path[start..]),

590:             Some(i) => (1, &self.path[start + i + 1..]),

597:         while !self.path.is_empty() {

602:                 self.path = &self.path[size..];

609:         while self.path.len() > self.len_before_body() {

614:                 self.path = &self.path[..self.path.len() - size];

620: impl AsRef<Path> for Components<'_> {

621:     fn as_ref(&self) -> &Path {

622:         self.as_path()

628:         self.as_path().as_os_str()

634:         struct DebugHelper<'a>(&'a Path);

645:             .field(&DebugHelper(self.as_path()))

651:     /// Extracts a slice corresponding to the portion of the path remaining for iteration.

654:         self.inner.as_path()

658: impl AsRef<Path> for Iter<'_> {

659:     fn as_ref(&self) -> &Path {

660:         self.as_path()

666:         self.as_path().as_os_str()

694:                     debug_assert!(self.prefix_len() <= self.path.len());

695:                     let raw = &self.path[..self.prefix_len()];

696:                     self.path = &self.path[self.prefix_len()..];

708:                         debug_assert!(!self.path.is_empty());

709:                         self.path = &self.path[1..];

716:                         debug_assert!(!self.path.is_empty());

717:                         self.path = &self.path[1..];

721:                 State::Body if !self.path.is_empty() => {

723:                     self.path = &self.path[size..];

742:                 State::Body if self.path.len() > self.len_before_body() => {

744:                     self.path = &self.path[..self.path.len() - size];

755:                         self.path = &self.path[..self.path.len() - 1];

762:                         self.path = &self.path[..self.path.len() - 1];

769:                         raw: unsafe { u8_slice_as_os_str(self.path) },

806: /// An iterator over [`Path`] and its ancestors.

808: /// This `struct` is created by the [`ancestors`] method on [`Path`].

813:     next: Option<&'a Path>,

817:     type Item = &'a Path;

821:         self.next = next.and_then(Path::parent);

832: /// An owned, mutable path (akin to [`String`]).

835: /// the path in place. It also implements [`Deref`] to [`Path`], meaning that

836: /// all methods on [`Path`] slices are available on `PathBuf` values as well.

839: /// [`Path`]: struct.Path.html

872:     /// Coerces to a [`Path`] slice.

874:     /// [`Path`]: struct.Path.html

880:     /// Extends `self` with `path`.

882:     /// If `path` is absolute, it replaces the current path.

886:     /// * if `path` has a root but no prefix (e.g., `\windows`), it

888:     /// * if `path` has a prefix but no root, it replaces `self`.

890:     pub fn push<P: AsRef<Path>>(&mut self, path: P) {

891:         self._push(path.as_ref())

894:     fn _push(&mut self, path: &Path) {

901:             if comps.prefix_len() > 0 && comps.prefix_len() == comps.path.len() &&

907:         // absolute `path` replaces `self`

908:         if path.is_absolute() || path.prefix().is_some() {

911:         // `path` has a root but no prefix, e.g., `\windows` (Windows only)

912:         } else if path.has_root() {

916:         // `path` is a pure relative path

921:         self.inner.push(path);

949:     /// `file_name`. The new path will be a sibling of the original path.

1011:     /// Converts this `PathBuf` into a [boxed][`Box`] [`Path`].

1014:     /// [`Path`]: struct.Path.html

1016:         let rw = Box::into_raw(self.inner.into_boxed_os_str()) as *mut Path;

1069: impl From<&Path> for Box<Path> {

1070:     fn from(path: &Path) -> Box<Path> {

1071:         let boxed: Box<OsStr> = path.inner.into();

1072:         let rw = Box::into_raw(boxed) as *mut Path;

1078:     /// Converts a `Box<Path>` into a `PathBuf`

1081:     fn from(boxed: Box<Path>) -> PathBuf {

1082:         boxed.into_path_buf()

1086: impl From<PathBuf> for Box<Path> {

1087:     /// Converts a `PathBuf` into a `Box<Path>`

1091:     fn from(p: PathBuf) -> Box<Path> {

1092:         p.into_boxed_path()

1096: impl Clone for Box<Path> {

1099:         self.to_path_buf().into_boxed_path()

1122:     fn from(path_buf : PathBuf) -> OsString {

1123:         path_buf.inner

1165:     type Target = Path;

1167:     fn deref(&self) -> &Path {

1168:         Path::new(&self.inner)

1173:     fn borrow(&self) -> &Path {

1184: impl<'a> From<&'a Path> for Cow<'a, Path> {

1186:     fn from(s: &'a Path) -> Cow<'a, Path> {

1191: impl<'a> From<PathBuf> for Cow<'a, Path> {

1193:     fn from(s: PathBuf) -> Cow<'a, Path> {

1198: impl<'a> From<&'a PathBuf> for Cow<'a, Path> {

1200:     fn from(p: &'a PathBuf) -> Cow<'a, Path> {

1201:         Cow::Borrowed(p.as_path())

1207:     fn from(p: Cow<'a, Path>) -> Self {

1212: impl From<PathBuf> for Arc<Path> {

1213:     /// Converts a Path into a Rc by copying the Path data into a new Rc buffer.

1215:     fn from(s: PathBuf) -> Arc<Path> {

1217:         unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Path) }

1221: impl From<&Path> for Arc<Path> {

1222:     /// Converts a Path into a Rc by copying the Path data into a new Rc buffer.

1224:     fn from(s: &Path) -> Arc<Path> {

1226:         unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Path) }

1230: impl From<PathBuf> for Rc<Path> {

1231:     /// Converts a Path into a Rc by copying the Path data into a new Rc buffer.

1233:     fn from(s: PathBuf) -> Rc<Path> {

1235:         unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Path) }

1239: impl From<&Path> for Rc<Path> {

1240:     /// Converts a Path into a Rc by copying the Path data into a new Rc buffer.

1242:     fn from(s: &Path) -> Rc<Path> {

1244:         unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Path) }

1251:         self.to_path_buf()

1266:         self.as_path().hash(h)

1290: /// A slice of a path (akin to [`str`]).

1292: /// This type supports a number of operations for inspecting a path, including

1293: /// breaking the path into its components (separated by `/` on Unix and by either

1294: /// `/` or `\` on Windows), extracting the file name, determining whether the path

1312: /// An error returned from [`Path::strip_prefix`][`strip_prefix`] if the prefix

1315: /// This `struct` is created by the [`strip_prefix`] method on [`Path`].

1318: /// [`strip_prefix`]: struct.Path.html#method.strip_prefix

1319: /// [`Path`]: struct.Path.html

1324:     // The following (private!) function allows construction of a path from a u8

1326:     unsafe fn from_u8_slice(s: &[u8]) -> &Path {

1327:         Path::new(u8_slice_as_os_str(s))

1334:     /// Directly wraps a string slice as a `Path` slice.

1338:     pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path {

1339:         unsafe { &*(s.as_ref() as *const OsStr as *const Path) }

1350:     /// Yields a [`&str`] slice if the `Path` is valid unicode.

1360:     /// Converts a `Path` to a [`Cow<str>`].

1372:     /// Converts a `Path` to an owned [`PathBuf`].

1381:     /// Returns `true` if the `Path` is absolute, i.e., if it is independent of

1384:     /// * On Unix, a path is absolute if it starts with the root, so

1387:     /// * On Windows, a path is absolute if it has a prefix and starts with the

1395:     /// Returns `true` if the `Path` is relative, i.e., not absolute.

1407:     /// Returns `true` if the `Path` has a root.

1409:     /// * On Unix, a path has a root if it begins with `/`.

1411:     /// * On Windows, a path has a root if it:

1420:     /// Returns the `Path` without its final component, if there is one.

1422:     /// Returns [`None`] if the path terminates in a root or prefix.

1426:     pub fn parent(&self) -> Option<&Path> {

1433:                 Component::ParentDir => Some(comps.as_path()),

1439:     /// Produces an iterator over `Path` and its ancestors.

1441:     /// The iterator will yield the `Path` that is returned if the [`parent`] method is used zero

1453:     /// Returns the final component of the `Path`, if there is one.

1455:     /// If the path is a normal file, this is the file name. If it's the path of a directory, this

1458:     /// Returns [`None`] if the path terminates in `..`.

1471:     /// Returns a path that, when joined onto `base`, yields `self`.

1482:                            -> Result<&Path, StripPrefixError>

1483:         where P: AsRef<Path>

1488:     fn _strip_prefix(&self, base: &Path)

1489:                      -> Result<&Path, StripPrefixError> {

1491:             .map(|c| c.as_path())

1497:     /// Only considers whole path components to match.

1499:     pub fn starts_with<P: AsRef<Path>>(&self, base: P) -> bool {

1503:     fn _starts_with(&self, base: &Path) -> bool {

1509:     /// Only considers whole path components to match.

1511:     pub fn ends_with<P: AsRef<Path>>(&self, child: P) -> bool {

1515:     fn _ends_with(&self, child: &Path) -> bool {

1521:     /// [`self.file_name`]: struct.Path.html#method.file_name

1545:     /// [`self.file_name`]: struct.Path.html#method.file_name

1552:     /// Creates an owned [`PathBuf`] with `path` adjoined to `self`.

1554:     /// See [`PathBuf::push`] for more details on what it means to adjoin a path.

1559:     pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf {

1560:         self._join(path.as_ref())

1563:     fn _join(&self, path: &Path) -> PathBuf {

1564:         let mut buf = self.to_path_buf();

1565:         buf.push(path);

1581:         let mut buf = self.to_path_buf();

1598:         let mut buf = self.to_path_buf();

1603:     /// Produces an iterator over the [`Component`]s of the path.

1605:     /// When parsing the path, there is a small amount of normalization:

1611:     ///   beginning of the path. For example, `a/./b`, `a/b/`, `a/b/.` and

1624:             path: self.as_u8_slice(),

1632:     /// Produces an iterator over the path's components viewed as [`OsStr`]

1635:     /// For more information about the particulars of how the path is separated

1651:         Display { path: self }

1679:     /// Returns the canonical, absolute form of the path with all intermediate

1716:     /// use std::path::Path;

1718:     /// let path = Path::new("/laputa");

1719:     /// for entry in path.read_dir().expect("read_dir call failed") {

1721:     ///         println!("{:?}", entry.path());

1729:     /// Returns whether the path points at an existing entity.

1742:     /// Returns `true` if the path exists on disk and is pointing at a regular file.

1755:     /// Returns `true` if the path exists on disk and is pointing at a directory.

1768:     /// Converts a [`Box<Path>`][`Box`] into a [`PathBuf`] without copying or

1794: /// A [`Path`] might contain non-Unicode data. This `struct` implements the

1796: /// [`display`][`Path::display`] method on [`Path`].

1804:         fmt::Debug::fmt(&self.path, f)

1810:         self.path.inner.display(f)

1815:     fn eq(&self, other: &Path) -> bool {

1831:     fn partial_cmp(&self, other: &Path) -> Option<cmp::Ordering> {

1837:     fn cmp(&self, other: &Path) -> cmp::Ordering {

1843:     fn as_ref(&self) -> &Path {

1848: impl AsRef<Path> for OsStr {

1849:     fn as_ref(&self) -> &Path {

1850:         Path::new(self)

1854: impl AsRef<Path> for Cow<'_, OsStr> {

1855:     fn as_ref(&self) -> &Path {

1856:         Path::new(self)

1860: impl AsRef<Path> for OsString {

1861:     fn as_ref(&self) -> &Path {

1862:         Path::new(self)

1866: impl AsRef<Path> for str {

1867:     fn as_ref(&self) -> &Path {

1868:         Path::new(self)

1872: impl AsRef<Path> for String {

1873:     fn as_ref(&self) -> &Path {

1874:         Path::new(self)

1879:     fn as_ref(&self) -> &Path {

1900:             fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other) }

1905:             fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self, other) }

1911:                 <Path as PartialOrd>::partial_cmp(self, other)

1918:                 <Path as PartialOrd>::partial_cmp(self, other)

1924: impl_cmp!(PathBuf, Path);

1925: impl_cmp!(PathBuf, &'a Path);

1926: impl_cmp!(Cow<'a, Path>, Path);

1927: impl_cmp!(Cow<'a, Path>, &'b Path);

1928: impl_cmp!(Cow<'a, Path>, PathBuf);

1934:             fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other.as_ref()) }

1939:             fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self.as_ref(), other) }

1945:                 <Path as PartialOrd>::partial_cmp(self, other.as_ref())

1952:                 <Path as PartialOrd>::partial_cmp(self.as_ref(), other)

1962: impl_cmp_os_str!(Path, OsStr);

1963: impl_cmp_os_str!(Path, &'a OsStr);

1964: impl_cmp_os_str!(Path, Cow<'a, OsStr>);

1965: impl_cmp_os_str!(Path, OsString);

1966: impl_cmp_os_str!(&'a Path, OsStr);

1967: impl_cmp_os_str!(&'a Path, Cow<'b, OsStr>);

1968: impl_cmp_os_str!(&'a Path, OsString);

1969: impl_cmp_os_str!(Cow<'a, Path>, OsStr);

1970: impl_cmp_os_str!(Cow<'a, Path>, &'b OsStr);

1971: impl_cmp_os_str!(Cow<'a, Path>, OsString);

32: //! and [`str`]), for working with paths abstractly. These types are thin wrappers

36: //! Paths can be parsed into [`Component`]s by iterating over the structure

40: //! [`PathBuf`]; note that the paths may differ syntactically by the

840: /// [`push`]: struct.PathBuf.html#method.push

841: /// [`set_extension`]: struct.PathBuf.html#method.set_extension

854:         unsafe { &mut *(self as *mut PathBuf as *mut Vec<u8>) }

857:     /// Allocates an empty `PathBuf`.

859:     pub fn new() -> PathBuf {

860:         PathBuf { inner: OsString::new() }

863:     /// Creates a new `PathBuf` with a given capacity used to create the

866:     pub fn with_capacity(capacity: usize) -> PathBuf {

867:         PathBuf {

930:     /// [`self.parent`]: struct.PathBuf.html#method.parent

952:     /// [`self.file_name`]: struct.PathBuf.html#method.file_name

954:     /// [`pop`]: struct.PathBuf.html#method.pop

976:     /// [`self.file_name`]: struct.PathBuf.html#method.file_name

977:     /// [`self.extension`]: struct.PathBuf.html#method.extension

1003:     /// Consumes the `PathBuf`, yielding its internal [`OsString`] storage.

1104:     fn from(s: &T) -> PathBuf {

1105:         PathBuf::from(s.as_ref().to_os_string())

1110:     /// Converts a `OsString` into a `PathBuf`

1113:     fn from(s: OsString) -> PathBuf {

1114:         PathBuf { inner: s }

1118: impl From<PathBuf> for OsString {

1119:     /// Converts a `PathBuf` into a `OsString`

1128:     /// Converts a `String` into a `PathBuf`

1131:     fn from(s: String) -> PathBuf {

1132:         PathBuf::from(OsString::from(s))

1140:         Ok(PathBuf::from(s))

1145:     fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> PathBuf {

1146:         let mut buf = PathBuf::new();

1180:         PathBuf::new()

1249:     type Owned = PathBuf;

1250:     fn to_owned(&self) -> PathBuf {

1253:     fn clone_into(&self, target: &mut PathBuf) {

1259:     fn eq(&self, other: &PathBuf) -> bool {

1273:     fn partial_cmp(&self, other: &PathBuf) -> Option<cmp::Ordering> {

1279:     fn cmp(&self, other: &PathBuf) -> cmp::Ordering {

1299: /// see [`PathBuf`].

1303: /// [`PathBuf`]: struct.PathBuf.html

1374:     /// [`PathBuf`]: struct.PathBuf.html

1378:         PathBuf::from(self.inner.to_os_string())

1556:     /// [`PathBuf`]: struct.PathBuf.html

1557:     /// [`PathBuf::push`]: struct.PathBuf.html#method.push

1569:     /// Creates an owned [`PathBuf`] like `self` but with the given file name.

1571:     /// See [`PathBuf::set_file_name`] for more details.

1573:     /// [`PathBuf`]: struct.PathBuf.html

1574:     /// [`PathBuf::set_file_name`]: struct.PathBuf.html#method.set_file_name

1576:     pub fn with_file_name<S: AsRef<OsStr>>(&self, file_name: S) -> PathBuf {

1580:     fn _with_file_name(&self, file_name: &OsStr) -> PathBuf {

1586:     /// Creates an owned [`PathBuf`] like `self` but with the given extension.

1588:     /// See [`PathBuf::set_extension`] for more details.

1590:     /// [`PathBuf`]: struct.PathBuf.html

1591:     /// [`PathBuf::set_extension`]: struct.PathBuf.html#method.set_extension

1593:     pub fn with_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf {

1597:     fn _with_extension(&self, extension: &OsStr) -> PathBuf {

1645:     /// Returns an object that implements [`Display`] for safely printing paths

1687:     pub fn canonicalize(&self) -> io::Result<PathBuf> {

1698:     pub fn read_link(&self) -> io::Result<PathBuf> {

1772:     /// [`PathBuf`]: struct.PathBuf.html

1776:         PathBuf { inner: OsString::from(inner) }

1792: /// Helper struct for safely printing paths with [`format!`] and `{}`.

1958: impl_cmp_os_str!(PathBuf, OsStr);

1959: impl_cmp_os_str!(PathBuf, &'a OsStr);

1960: impl_cmp_os_str!(PathBuf, Cow<'a, OsStr>);

1961: impl_cmp_os_str!(PathBuf, OsString);

64: public class Path extends FilledElement

82:     public function Path()

1196: class PathSegmentsCollection

1214: public function PathSegmentsCollection(value:String)

1540: public function generateGraphicsPath(graphicsPath:GraphicsPath,

1742: public function PathSegment(_x:Number = 0, _y:Number = 0)

39:  *  The Path class is a filled graphic element that draws a series of path segments.

40:  *  In vector graphics, a path is a series of points connected by straight or curved line segments. 

41:  *  Together the lines form an image. In Flex, you use the Path class to define a complex vector shape 

44:  *  <p>Typically, the first element of a path definition is a Move segment to specify the starting pen 

51:  *  point of the line. You can use multiple Move segments in the path definition to 

54:  *  <p>The syntax used by the Path class to define the shape is the same as the SVG path syntax, 

94:      *  Dirty flag to indicate when path data has changed. 

105:      *  path segment information  

116:      *  commands to draw this Path.  

118:      *  The data commands expressed in a Path's <code>data</code> 

140:      *  A string containing a compact represention of the path segments. This is an alternate

144:      *  <p>The value is a space-delimited string describing each path segment. Each

198:      *      <td>Close path</td>

201:      *      <td>Closes off the path.</td>

245:      *  Fill rule for intersecting or overlapping path segments. 

322:      *  Returns the bounding box for the path including stroke, if the path is resized

406:      *  @return Returns the axis aligned bounding box of the path when

420:         // then the non-stroked path bounds for the give size can be

556:         // slow code-path Player execution for all graphics in that DisplayObject.

708:      *  if the path is resized to the specified size.

947:         // Resize transformed path with the iterative solution

962:         // the path size as the size changes the angles of the joints.

1193:  *  Path segments.

1452:  *  A Vector of the actual path segments. May be empty, but always non-null. 

1510:     // If path is empty, it's untransformed bounding box is (0,0), so we return transformed point (0,0)

1522:  *  array and draws each path egment based on its control points. 

1524:  *  Segments are drawn from the x and y position of the path. 

1526:  *  applied to the path. 

1529:  *  path segment should be drawn

1532:  *  path segment should be drawn

1535:  *  this path segment 

1538:  *  path segment

1550:     // the path will begin at the previous pen location

1712:  *  The PathSegment class is the base class for a segment of a path.

1794:  *  Draws this path segment. You can determine the current pen position by 

1817:  *  path segment.

24: import flash.display.GraphicsPath;

55:  *  which makes it easy to convert SVG paths to Flex paths.</p>

112:     private var segments:PathSegmentsCollection;

115:      *  A GraphicsPath object that contains the drawing 

123:     mx_internal var graphicsPath:GraphicsPath = new GraphicsPath(new Vector.<int>(), new Vector.<Number>());

218:         segments = new PathSegmentsCollection(value);

392:     private function tangentIsValid(prevSegment:PathSegment, curSegment:PathSegment,

418:         var pathBBox:Rectangle;

424:             pathBBox = new Rectangle(naturalBounds.x * sx,

429:                 pathBBox.offset(m.tx, m.ty);

433:             pathBBox = this.segments.getBoundingBox(width, height, m);

439:             return pathBBox;

441:         // Always add half the stroke weight, even for miter limit paths,

445:         pathBBox.inflate(strokeExtents.right, strokeExtents.bottom);

447:         var seg:Vector.<PathSegment> = segments.data;

453:             return pathBBox;

473:                 var prevSegment:PathSegment = start > 0 ? seg[start - 1] : null;

482:             var startSegment:PathSegment = seg[start];

519:             var endSegment:PathSegment = seg[end];

531:                     pathBBox);

538:         return pathBBox;

582:     private function addMiterLimitStrokeToBounds(segment0:PathSegment,

583:                                                  segment1:PathSegment,

584:                                                  segment2:PathSegment,

939:         // We have special handling for miter-limit stroked non-transformed paths,

1098:                 segments.generateGraphicsPath(graphicsPath, drawX, drawY, sx, sy);

1102:         g.drawPath(graphicsPath.commands, graphicsPath.data, winding);

1187: //  Internal Helper Class - PathSegmentsCollection

1194:  *  Provides methods for generating GraphicsPath and calculating bounds. 

1218:         _segments = new Vector.<PathSegment>();

1222:     var newSegments:Vector.<PathSegment> = new Vector.<PathSegment>();

1418:                 _segments = new Vector.<PathSegment>();

1449: private var _segments:Vector.<PathSegment>;

1454: public function get data():Vector.<PathSegment>

1499:     var prevSegment:PathSegment;

1500:     var pathBBox:Rectangle;

1505:         var segment:PathSegment = _segments[i];

1506:         pathBBox = segment.getBoundingBox(prevSegment, sx, sy, m, pathBBox);

1511:     if (!pathBBox)

1515:         pathBBox = new Rectangle(x, y);

1517:     return pathBBox;

1546:     graphicsPath.commands = null;

1547:     graphicsPath.data = null;

1552:     graphicsPath.moveTo(tx, ty);

1554:     var curSegment:PathSegment;

1555:     var prevSegment:PathSegment;

1561:         curSegment.draw(graphicsPath, tx, ty, sx, sy, prevSegment);

1702: //  Internal Helper Class - PathSegment 

1705: import flash.display.GraphicsPath;

1721: class PathSegment extends Object

1805: public function draw(graphicsPath:GraphicsPath, dx:Number,dy:Number,sx:Number,sy:Number,prev:PathSegment):void

1824: public function getBoundingBox(prev:PathSegment, sx:Number, sy:Number, m:Matrix, rect:Rectangle):Rectangle

1839: public function getTangent(prev:PathSegment, start:Boolean, sx:Number, sy:Number, m:Matrix, result:Point):void

1853: import flash.display.GraphicsPath;

1869: class LineSegment extends PathSegment

1911: override public function draw(graphicsPath:GraphicsPath, dx:Number,dy:Number,sx:Number,sy:Number,prev:PathSegment):void

1913:     graphicsPath.lineTo(dx + x*sx, dy + y*sy);

1924: override public function getBoundingBox(prev:PathSegment, sx:Number, sy:Number, m:Matrix, rect:Rectangle):Rectangle

1952: override public function getTangent(prev:PathSegment, start:Boolean, sx:Number, sy:Number, m:Matrix, result:Point):void

1967: import flash.display.GraphicsPath;

1981: class MoveSegment extends PathSegment

2024: override public function draw(graphicsPath:GraphicsPath, dx:Number,dy:Number,sx:Number,sy:Number,prev:PathSegment):void

2026:     graphicsPath.moveTo(dx+x*sx, dy+y*sy);

2036: import flash.display.GraphicsPath;

2061: class CubicBezierSegment extends PathSegment

2198:     override public function draw(graphicsPath:GraphicsPath, dx:Number, dy:Number, sx:Number, sy:Number, prev:PathSegment):void

2202:         graphicsPath.curveTo(dx + qPts.control1.x*sx, dy+qPts.control1.y*sy, dx+qPts.anchor1.x*sx, dy+qPts.anchor1.y*sy)...(1 bytes skipped)...

2203:         graphicsPath.curveTo(dx + qPts.control2.x*sx, dy+qPts.control2.y*sy, dx+qPts.anchor2.x*sx, dy+qPts.anchor2.y*sy)...(1 bytes skipped)...

2204:         graphicsPath.curveTo(dx + qPts.control3.x*sx, dy+qPts.control3.y*sy, dx+qPts.anchor3.x*sx, dy+qPts.anchor3.y*sy)...(1 bytes skipped)...

2205:         graphicsPath.curveTo(dx + qPts.control4.x*sx, dy+qPts.control4.y*sy, dx+qPts.anchor4.x*sx, dy+qPts.anchor4.y*sy)...(1 bytes skipped)...

2216:     override public function getBoundingBox(prev:PathSegment, sx:Number, sy:Number,

2252:     override public function getTangent(prev:PathSegment, start:Boolean, sx:Number, sy:Number, m:Matrix, result:Point):void

2318:     private function getQuadraticPoints(prev:PathSegment):QuadraticPoints

2411: import flash.display.GraphicsPath;

2431: class QuadraticBezierSegment extends PathSegment

2526:     override public function draw(graphicsPath:GraphicsPath, dx:Number,dy:Number,sx:Number,sy:Number,prev:PathSegment):void

2528:         graphicsPath.curveTo(dx+control1X*sx, dy+control1Y*sy, dx+x*sx, dy+y*sy);

2574:     override public function getTangent(prev:PathSegment, start:Boolean, sx:Number, sy:Number, m:Matrix, result:Point):void

2591:     override public function getBoundingBox(prev:PathSegment, sx:Number, sy:Number,

101:     private var graphicsPathChanged:Boolean = true;

220:         graphicsPathChanged = true;

246:      *  Possible values are <code>GraphicsPathWinding.EVEN_ODD</code> or <code>GraphicsPathWinding.NON_ZERO</code>.

250:      *  @see flash.display.GraphicsPathWinding 

262:             graphicsPathChanged = true;

1085:             graphicsPathChanged = true;

1092:         if (graphicsPathChanged)

1099:             graphicsPathChanged = false;

1139:         graphicsPathChanged = true;

43: class Path:

114: path = Path()

30: <path id="%s" transform="translate (%d,%d)"

55:             path.name = namematch.group(1)

59:                path.gimppoints.append ([])

61:             path.gimppoints[-1].append (map (int, pointmatch.groups()))

71:       for path in self.gimppoints:

72:          if path:

73:             start = path[0]

75:             path = path[1:]

76:             while path:

77:                curve = path [0:3]

78:                path = path[3:]

115: path.readgimpfile (infile)

116: path.makesvg()

117: path.writesvgfile (outfile)

6: gimppath2svg.py -- Converts Gimp-Paths to a SVG-File.

23: Usage: gimppath2svg.py [infile [outfile]]

46:       self.svgpath = ""

89:             self.svgpath = self.svgpath + svg

92:       if self.svgpath:

97:                               self.svgpath)

176: class Path(text_type):

1717: class path(Path):

294:     def abspath(self):

302:     def normpath(self):

306:     def realpath(self):

383:     def splitpath(self):

441:     def joinpath(cls, first, *others):

475:     def relpath(self, start='.'):

1141:         def pathconf(self, name):

482:     def relpathto(self, dest):

2: # SOURCE: https://pypi.python.org/pypi/path.py

27: path.py - An object representing a path to a file or directory.

29: https://github.com/jaraco/path.py

33:     from path import Path

34:     d = Path('/home/guido/bin')

113: __all__ = ['Path', 'CaseInsensitivePattern']

126:     __version__ = pkg_resources.require('path.py')[0].version

143:     Save results for the :meth:'path.using_module' classmethod.

178:     Represents a filesystem path.

181:     counterparts in :mod:`os.path`.

185:     such that they will be bound to the Path instance. For example,

186:     ``Path(src).copy(target)`` is equivalent to

189:     the Path instance.

192:     module = os.path

193:     """ The path module to use for path operations.

195:     .. seealso:: :mod:`os.path`

200:             raise TypeError("Invalid initial value for path: None")

221:     def _always_unicode(cls, path):

223:         Ensure the path as retrieved from a Python API, such as :func:`os.listdir`,

226:         if PY3 or isinstance(path, text_type):

227:             return path

228:         return path.decode(sys.getfilesystemencoding(), 'surrogateescape')

233:         return '%s(%s)' % (type(self).__name__, super(Path, self).__repr__())

235:     # Adding a Path and a string yields a Path.

238:             return self._next_class(super(Path, self).__add__(more))

251:         Join two path components, adding a separator character if

254:         .. seealso:: :func:`os.path.join`

265:         Join two path components, adding a separator character if

268:         .. seealso:: :func:`os.path.join`

285:         """ Return the current working directory as a path object.

292:     # --- Operations on Path strings.

295:         """ .. seealso:: :func:`os.path.abspath` """

299:         """ .. seealso:: :func:`os.path.normcase` """

303:         """ .. seealso:: :func:`os.path.normpath` """

307:         """ .. seealso:: :func:`os.path.realpath` """

311:         """ .. seealso:: :func:`os.path.expanduser` """

315:         """ .. seealso:: :func:`os.path.expandvars` """

319:         """ .. seealso:: :attr:`parent`, :func:`os.path.dirname` """

323:         """ .. seealso:: :attr:`name`, :func:`os.path.basename` """

340:         ``Path('/home/guido/python.tar.gz').name == 'python.tar.gz'``,

342:         ``Path('/home/guido/python.tar.gz').namebase == 'python.tar'``.

364:         """ This path's parent directory, as a new Path object.

367:         ``Path('/usr/local/lib/libpython.so').parent ==

368:         Path('/usr/local/lib')``

370:         .. seealso:: :meth:`dirname`, :func:`os.path.dirname`

375:         """ The name of this file or directory without the full path.

378:         ``Path('/usr/local/lib/libpython.so').name == 'libpython.so'``

380:         .. seealso:: :meth:`basename`, :func:`os.path.basename`

386:         .. seealso:: :attr:`parent`, :attr:`name`, :func:`os.path.split`

394:         Split the drive specifier from this path.  If there is

396:         is simply ``(Path(''), p)``.  This is always the case on Unix.

398:         .. seealso:: :func:`os.path.splitdrive`

406:         Split the filename extension from this path and return

410:         last path segment.  This has the property that if

413:         .. seealso:: :func:`os.path.splitext`

419:         """ p.stripext() -> Remove one file extension from the path.

421:         For example, ``Path('/home/guido/python.tar.gz').stripext()``

422:         returns ``Path('/home/guido/python.tar')``.

427:         """ .. seealso:: :func:`os.path.splitunc` """

434:         The UNC mount point for this path.

443:         Join first to zero or more :class:`Path` components, adding a separator

447:         .. seealso:: :func:`os.path.join`

454:         r""" Return a list of the path components in this path.

456:         The first item in the list will be a Path.  Its value will be

458:         directory of this path (for example, ``'/'`` or ``'C:\\'``).  The

461:         ``path.Path.joinpath(*result)`` will yield the original path.

476:         """ Return this path as a relative path,

483:         """ Return a relative path from `self` to `dest`.

485:         If there is no relative path from `self` to `dest`, for example if

528:         The elements of the list are Path objects.

546:         The elements of the list are Path objects.

559:         The elements of the list are Path objects.

572:         The iterator yields Path objects naming each child item of

713:             attribute, it is applied to the name and path prior to comparison.

717:             to :meth:`os.path.normcase`.

728:         """ Return a list of Path objects that match the pattern.

730:         `pattern` - a path relative to this directory, with wildcards.

732:         For example, ``Path('/users').glob('*/bin/*')`` returns a list

766:                >>> for chunk in Path("path.py").chunks(8192, mode='rb'):

902:         By default this overwrites any existing file at this path.

956:         """ Returns a hash object for the file at the current path.

987:     # N.B. On some platforms, the os.path functions may be implemented in C

992:         """ .. seealso:: :func:`os.path.isabs` """

996:         """ .. seealso:: :func:`os.path.exists` """

1000:         """ .. seealso:: :func:`os.path.isdir` """

1004:         """ .. seealso:: :func:`os.path.isfile` """

1008:         """ .. seealso:: :func:`os.path.islink` """

1012:         """ .. seealso:: :func:`os.path.ismount` """

1016:         """ .. seealso:: :func:`os.path.samefile` """

1018:             other = Path(other).realpath().normpath().normcase()

1023:         """ .. seealso:: :attr:`atime`, :func:`os.path.getatime` """

1030:         .. seealso:: :meth:`getatime`, :func:`os.path.getatime`

1034:         """ .. seealso:: :attr:`mtime`, :func:`os.path.getmtime` """

1041:         .. seealso:: :meth:`getmtime`, :func:`os.path.getmtime`

1045:         """ .. seealso:: :attr:`ctime`, :func:`os.path.getctime` """

1052:         .. seealso:: :meth:`getctime`, :func:`os.path.getctime`

1056:         """ .. seealso:: :attr:`size`, :func:`os.path.getsize` """

1063:         .. seealso:: :meth:`getsize`, :func:`os.path.getsize`

1068:             """ Return ``True`` if current user has access to this path.

1078:         """ Perform a ``stat()`` system call on this path.

1134:             """ Perform a ``statvfs()`` system call on this path.

1322:             """ Return the path to which this symbolic link points.

1324:             The result may be an absolute or a relative path.

1331:             """ Return the path to which this symbolic link points.

1333:             The result is always an absolute path.

1345:     # Path(name).copy(target) will invoke shutil.copy(name, target)

1432:             p = Path(filename)

1506:             dir = Path.special().user.config

1514:             dir = Path.special("My App").user.config.makedirs_p()

1531:     def __init__(self, path_class, *args, **kwargs):

1539:             path_class=path_class,

1549:         result wrapped in self.path_class

1553:         MultiPath = Multi.for_class(self.path_class)

1559:     A mix-in for a Path which may contain multiple Path separated by pathsep.

1562:     def for_class(cls, path_cls):

1563:         name = 'Multi' + path_cls.__name__

1566:         return type(name, (cls, path_cls), {})

1590: class tempdir(Path):

1598:             # do stuff with the Path object "d"

1608:         return Path

1707:         from path import Path, CaseInsensitivePattern as ci

1708:         Path('.').files(ci('*.py'))

1719:         msg = "path is deprecated. Use Path instead."

1721:         return Path.__new__(cls, *args, **kwargs)

1724: __all__ += ['path']

247:     # The / operator joins Paths.

249:         """ fp.__div__(rel) == fp / rel == fp.joinpath(rel)

261:     # The / operator joins Paths the other way around

296:         return self._next_class(self.module.abspath(self))

304:         return self._next_class(self.module.normpath(self))

308:         return self._next_class(self.module.realpath(self))

328:         :meth:`expanduser()`, and :meth:`normpath()` on it.

333:         return self.expandvars().expanduser().normpath()

384:         """ p.splitpath() -> Return ``(p.parent, p.name)``.

435:         This is empty for paths on local drives.

467:             loc, child = prev.splitpath()

487:         ``dest.abspath()``.

489:         origin = self.abspath()

490:         dest = self._next_class(dest).abspath()

500:         # Find the location where the two paths start to differ.

507:         # Now i is the point where the two paths diverge.

515:             relpath = os.curdir

517:             relpath = self.module.join(*segments)

518:         return self._next_class(relpath)

1019:             return self.realpath().normpath().normcase() == other

1140:     if hasattr(os, 'pathconf'):

1142:             """ .. seealso:: :func:`os.pathconf` """

1143:             return os.pathconf(self, name)

1303:         def link(self, newpath):

1304:             """ Create a hard link at `newpath`, pointing to this file.

1308:             os.link(self, newpath)

1309:             return self._next_class(newpath)

1341:                 return (self.parent / p).abspath()

1510:         the paths in a platform-friendly way.

1524:         def __init__(self, paths, scope):

1525:             self.paths = paths

1529:             return self.paths.get_dir(self.scope, class_)

1554:         return MultiPath.detect(value)

1570:         if os.pathsep not in input:

1575:         return iter(map(self._next_class, self.split(os.pathsep)))

1713:         return __import__('ntpath').normcase

480:         return cwd.relpathto(self)

26: type Path []PathStep

34: type PathStep interface {

151: type pathStep struct {

172: 	pathStep

211: 	pathStep

256: 	pathStep

270: 	pathStep

280: 	pathStep

290: 	pathStep

335: type pointerPath struct {

17: // Path is a list of PathSteps describing the sequence of operations to get

19: // The first Path element is always an operation-less PathStep that exists

37: 	// Type is the resulting type after performing the path step.

40: 	// Values is the resulting values after performing the path step.

65: func (pa *Path) push(s PathStep) {

69: func (pa *Path) pop() {

73: // Last returns the last PathStep in the Path.

74: // If the path is empty, this returns a non-nil PathStep that reports a nil Type.

75: func (pa Path) Last() PathStep {

79: // Index returns the ith step in the Path and supports negative indexing.

80: // A negative index starts counting from the tail of the Path such that -1

83: func (pa Path) Index(i int) PathStep {

93: // String returns the simplified path to a node.

94: // The simplified path only contains struct field accesses.

98: func (pa Path) String() string {

108: // GoString returns the path to a specific node using Go syntax.

112: func (pa Path) GoString() string {

329: // Path for whether px was ever encountered in the Path history of x, and

334: // in O(1) instead of O(N) where N is len(Path).

28: // PathStep is a union-type for specific operations to traverse

57: 	_ PathStep = StructField{}

58: 	_ PathStep = SliceIndex{}

59: 	_ PathStep = MapIndex{}

60: 	_ PathStep = Indirect{}

61: 	_ PathStep = TypeAssertion{}

62: 	_ PathStep = Transform{}

82: // If index is invalid, this returns a non-nil PathStep that reports a nil Type.

88: 		return pathStep{}

116: 		var nextStep PathStep

156: func (ps pathStep) Type() reflect.Type             { return ps.typ }

157: func (ps pathStep) Values() (vx, vy reflect.Value) { return ps.vx, ps.vy }

158: func (ps pathStep) String() string {

308: // pointerPath represents a dual-stack of pointers encountered when

313: // The pointerPath uses a map to represent a stack; where descension into a

331: // equal if both px and py have a cycle resulting from the same PathStep.

342: func (p *pointerPath) Init() {

354: func (p pointerPath) Push(vx, vy reflect.Value) (equal, visited bool) {

369: func (p pointerPath) Pop(vx, vy reflect.Value) {

12: class Path(object):

13:     def __init__(self, path):

14:         if isinstance(path, Path):

15:             _path = path._path

17:             _path = ensure_text(path)

19:                 _path = _path.encode("utf-8")

20:         self._path = _path

23:         return ensure_str("Path({})".format(ensure_text(self._path)))

26:         return ensure_text(self._path)

29:         return ensure_str(self._path)

32:         if isinstance(other, Path):

33:             right = other._path

38:         return Path(os.path.join(self._path, right))

44:         return self._path == (other._path if isinstance(other, Path) else None)

50:         return hash(self._path)

53:         return os.path.exists(self._path)

57:         return Path(os.path.abspath(os.path.join(self._path, os.path.pardir)))

60:         return Path(os.path.realpath(self._path))

64:         return os.path.basename(self._path)

68:         return self._path.split(os.sep)

71:         return os.path.isfile(self._path)

74:         return os.path.isdir(self._path)

78:             os.makedirs(self._path)

84:         with open(self._path, "rb") as file_handler:

88:         with open(self._path, "wb") as file_handler:

92:         for p in os.listdir(self._path):

93:             yield Path(os.path.join(self._path, p))

97:         _, ext = os.path.splitext(self.name)

102:         base, _ = os.path.splitext(self.name)

107:         with open(self._path, mode) as file_handler:

115:             result.append(Path(os.sep.join(parts[0 : i + 1])))

119:         os.remove(self._path)

125:         return os.path.islink(self._path)

128:         if not self._path.startswith(other._path):

129:             raise ValueError("{} does not start with {}".format(self._path, other._path))

130:         return Path(os.sep.join(self.parts[len(other.parts) :]))

133:         return os.stat(self._path)

136:         os.chmod(self._path, mode)

139: __all__ = ("Path",)

6: package path

76: 		o.Array = obj.(Path)

113: 	Package: "path",

116: 		{Declared: "Array", Type: &schema.Interface{Name: "Path"}},

163: 	Package: "path",

218: 	Package: "path",

284: 	Package: "path",

334: 	Package: "path",

383: 	Package: "path",

412: 		o.Struct = obj.(Path)

449: 	Package: "path",

452: 		{Declared: "Struct", Type: &schema.Interface{Name: "Path"}},

505: 	Package: "path",

554: 	Package: "path",

592: 		o.Map = obj.(Path)

633: 	Package: "path",

636: 		{Declared: "Map", Type: &schema.Interface{Name: "Path"}},

722: 	Package: "path",

780: 	Package: "path",

812: 		o.Array = obj.(Path)

857: 	Package: "path",

860: 		{Declared: "Array", Type: &schema.Interface{Name: "Path"}},

914: 	Package: "path",

963: 	Package: "path",

5:     <path id="path" d="M0 0 L1 1 L0 1 Z"/>

8: <div style="width: 200px; height: 200px; background: blue; clip-path: url(#clip); will-change: transform"></div>

11:   path.setAttribute('d', 'M0 0 L1 0 L1 1 L0 1 Z');

4: 	<clipPath id="clip" clipPathUnits='objectBoundingBox'>

6: 	</clipPath>

3: const path = require('path');

14:   pathMismatch(npmRoot) {

29: function fixPath(filepath) {

48:   const nodePaths = (process.env.NODE_PATH || '').split(path.delimiter).map(fixPath);

7: exports.description = 'NODE_PATH matches the npm root';

11:     return message.get('node-path-npm-failure', {});

15:     let msgPath = 'node-path-path-mismatch';

22:       path: process.env.NODE_PATH,

30:   let fixedPath = path.resolve(path.normalize(filepath.trim()));

44:   if (process.env.NODE_PATH === undefined) {

18:       msgPath += '-windows';

21:     return message.get(msgPath, {

33:     fixedPath = fs.realpathSync(fixedPath);

40:   return fixedPath;

52:     const npmRoot = fixPath(stdout);

55:       return errors.pathMismatch(npmRoot);

54:     if (nodePaths.indexOf(npmRoot) < 0) {

84: type Path struct {

89: type ErrPath string

98: func CompilePath(path string) (Path, error) {

111: func MustCompilePath(path string) Path {

148: type pather struct {

211: func (c *compiler) parsePath(path string) []segment {

235: func splitPath(path string) []string {

163: func newPather() *pather {

13: A Path is a string that represents a search path through an etree starting

17: A Path consists of a series of slash-separated "selectors", each of which may

22: Although etree Path strings are structurally and behaviorally similar to XPath

31:     /               Select the root element when used at the start of a path.

54: Below are some examples of etree path strings.

88: // ErrPath is returned by path functions when an invalid etree path is provided.

91: // Error returns the string describing a path error.

100: 	segments := comp.parsePath(path)

102: 		return Path{nil}, comp.err

104: 	return Path{segments}, nil

109: // occurs.  Use this function to create Paths when you know the path is

112: 	p, err := CompilePath(path)

119: // A segment is a portion of a path between "/" characters.

134: // path traversal.

140: // on a path filter in [brackets].

146: // a Path object.  It collects and deduplicates all elements matching

147: // the path query.

156: // A node represents an element and the remaining path segments that

172: // traverse follows the path from the element e, collecting

173: // and then returning all elements that match the path's selectors

175: func (p *pather) traverse(e *Element, path Path) []*Element {

176: 	for p.queue.add(node{e, path.segments}); p.queue.len() > 0; {

182: // eval evalutes the current path node by applying the remaining

183: // path's selector rules against the node's element.