825
+ 826
+ 827
+ 828
+ 829
+ 830
+ 831
+ 832
+ 833
+ 834
+ 835
+ 836
+ 837
+ 838
+ 839
+ 840
+ 841
+ 842
+ 843
+ 844
+ 845
+ 846
+ 847
+ 848
+ 849
+ 850
+ 851
+ 852
+ 853
+ 854
+ 855
+ 856
+ 857
+ 858
+ 859
+ 860
+ 861
+ 862
+ 863
+ 864
+ 865
+ 866
+ 867
+ 868
+ 869
+ 870
+ 871
+ 872
+ 873
+ 874
+ 875
+ 876
+ 877
+ 878
+ 879
+ 880
+ 881
+ 882
+ 883
+ 884
+ 885
+ 886
+ 887
+ 888
+ 889
+ 890
+ 891
+ 892
+ 893
+ 894
+ 895
+ 896
+ 897
+ 898
+ 899
+ 900
+ 901
+ 902
+ 903
+ 904
+ 905
+ 906
+ 907
+ 908
+ 909
+ 910
+ 911
+ 912
+ 913
+ 914
+ 915
+ 916
+ 917
+ 918
+ 919
+ 920
+ 921
+ 922
+ 923
+ 924
+ 925
+ 926
+ 927
+ 928
+ 929
+ 930
+ 931
+ 932
+ 933
+ 934
+ 935
+ 936
+ 937
+ 938
+ 939
+ 940
+ 941
+ 942
+ 943
+ 944
+ 945
+ 946
+ 947
+ 948
+ 949
+ 950
+ 951
+ 952
+ 953
+ 954
+ 955
+ 956
+ 957
+ 958
+ 959
+ 960
+ 961
+ 962
+ 963
+ 964
+ 965
+ 966
+ 967
+ 968
+ 969
+ 970
+ 971
+ 972
+ 973
+ 974
+ 975
+ 976
+ 977
+ 978
+ 979
+ 980
+ 981
+ 982
+ 983
+ 984
+ 985
+ 986
+ 987
+ 988
+ 989
+ 990
+ 991
+ 992
+ 993
+ 994
+ 995
+ 996
+ 997
+ 998
+ 999
+ 1000
+ 1001
+ 1002
+ 1003
+ 1004
+ 1005
+ 1006
+ 1007
+ 1008
+ 1009
+ 1010
+ 1011
+ 1012
+ 1013
+ 1014
+ 1015
+ 1016
+ 1017
+ 1018
+ 1019
+ 1020
+ 1021
+ 1022
+ 1023
+ 1024
+ 1025
+ 1026
+ 1027
+ 1028
+ 1029
+ 1030
+ 1031
+ 1032
+ 1033
+ 1034
+ 1035
+ 1036
+ 1037
+ 1038
+ 1039
+ 1040
+ 1041
+ 1042
+ 1043
+ 1044
+ 1045
+ 1046
+ 1047
+ 1048
+ 1049
+ 1050
+ 1051
+ 1052
+ 1053
+ 1054
+ 1055
+ 1056
+ 1057
+ 1058
+ 1059
+ 1060
+ 1061
+ 1062
+ 1063
+ 1064
+ 1065
+ 1066
+ 1067
+ 1068
+ 1069
+ 1070
+ 1071
+ 1072
+ 1073
+ 1074
+ 1075
+ 1076
+ 1077
+ 1078
+ 1079
+ 1080
+ 1081
+ 1082
+ 1083
+ 1084
+ 1085
+ 1086
+ 1087
+ 1088
+ 1089
+ 1090
+ 1091
+ 1092
+ 1093
+ 1094
+ 1095
+ 1096
+ 1097
+ 1098
+ 1099
+ 1100
+ 1101
+ 1102
+ 1103
+ 1104
+ 1105
+ 1106
+ 1107
+ 1108
+ 1109
+ 1110
+ 1111
+ 1112
+ 1113
+ 1114
+ 1115
+ 1116
+ 1117
+ 1118
+ 1119
+ 1120
+ 1121
+ 1122
+ 1123
+ 1124
+ 1125
+ 1126
+ 1127
+ 1128
+ 1129
+ 1130
+ 1131
+ 1132
+ 1133
+ 1134
+ 1135
+ 1136
+ 1137
+ 1138
+ 1139
+ 1140
+ 1141
+ 1142
+ 1143
+ 1144
+ 1145
+ 1146
+ 1147
+ 1148
+ 1149
+ 1150
+ 1151
+ 1152
+ 1153
+ 1154
+ 1155
+ 1156
+ 1157
+ 1158
+ 1159
+ 1160
+ 1161
+ 1162
+ 1163
+ 1164
+ 1165
+ 1166
+ 1167
+ 1168
+ 1169
+ 1170
+ 1171
+ 1172
+ 1173
+ 1174
+ 1175
+ 1176
+ 1177
+ 1178
+ 1179
+ 1180
+ 1181
+ 1182
+ 1183
+ 1184
+ 1185
+ 1186
+ 1187
+ 1188
+ 1189
+ 1190
+ 1191
+ 1192
+ 1193
+ 1194
+ 1195
+ 1196
+ 1197
+ 1198
+ 1199
+ 1200
+ 1201
+ 1202
+ 1203
+ 1204
+ 1205
+ 1206
+ 1207
+ 1208
+ 1209
+ 1210
+ 1211
+ 1212
+ 1213
+ 1214
+ 1215
+ 1216
+ 1217
+ 1218
+ 1219
+ 1220
+ 1221
+ 1222
+ 1223
+ 1224
+ 1225
+ 1226
+ 1227
+ 1228
+ 1229
+ 1230
+ 1231
+ 1232
+ 1233
+ 1234
+ 1235
+ 1236
+ 1237
+ 1238
+ 1239
+ 1240
+ 1241
+ 1242
+ 1243
+ 1244
+ 1245
+ 1246
+ 1247
+ 1248
+ 1249
+ 1250
+ 1251
+ 1252
+ 1253
+ 1254
+ 1255
+ 1256
+ 1257
+ 1258
+ 1259
+ 1260
+ 1261
+ 1262
+ 1263
+ 1264
+ 1265
+ 1266
+ 1267
+ 1268
+ 1269
+ 1270
+ 1271
+ 1272
+ 1273
+ 1274
+ 1275
+ 1276
+ 1277
+ 1278
+ 1279
+ 1280
+ 1281
+ 1282
+ 1283
+ 1284
+ 1285
+ 1286
+ 1287
+ 1288
+ 1289
+ 1290
+ 1291
+ 1292
+ 1293
+ 1294
+ 1295
+ 1296
+ 1297
+ 1298
+ 1299
+ 1300
+ 1301
+ 1302
+ 1303
+ 1304
+ 1305
+ 1306
+ 1307
+ 1308
+ 1309
+ 1310
+ 1311
+ 1312
+ 1313
+ 1314
+ 1315
+ 1316
+ 1317
+ 1318
+ 1319
+ 1320
+ 1321
+ 1322
+ 1323
+ 1324
+ 1325
+ 1326
+ 1327
+ 1328
+ 1329
+ 1330
+ 1331
+ 1332
+ 1333
+ 1334
+ 1335
+ 1336
+ 1337
+ 1338
+ 1339
+ 1340
+ 1341
+ 1342
+ 1343
+ 1344
+ 1345
+ 1346
+ 1347
+ 1348
+ 1349
+ 1350
+ 1351
+ 1352
+ 1353
+ 1354
+ 1355
+ 1356
+ 1357
+ 1358
+ 1359
+ 1360
+ 1361
+ 1362
+ 1363
+ 1364
+ 1365
+ 1366
+ 1367
+ 1368
+ 1369
+ 1370
+ 1371
+ 1372
+ 1373
+ 1374
+ 1375
+ 1376
+ 1377
+ 1378
+ 1379
+ 1380
+ 1381
+ 1382
+ 1383
+ 1384
+ 1385
+ 1386
+ 1387
+ 1388
+ 1389
+ 1390
+ 1391
+ 1392
+ 1393
+ 1394
+ 1395
+ 1396
+ 1397
+ 1398
+ 1399
+ 1400
+ 1401
+ 1402
+ 1403
+ 1404
+ 1405
+ 1406
+ 1407
+ 1408
+ 1409
+ 1410
+ 1411 | class Path(PurePath):
+ """PurePath subclass that can make system calls.
+
+ Path represents a filesystem path but unlike PurePath, also offers
+ methods to do system calls on path objects. Depending on your system,
+ instantiating a Path will return either a PosixPath or a WindowsPath
+ object. You can also instantiate a PosixPath or WindowsPath directly,
+ but cannot instantiate a WindowsPath on a POSIX system or vice versa.
+ """
+ __slots__ = ()
+
+ def stat(self, *, follow_symlinks=True):
+ """
+ Return the result of the stat() system call on this path, like
+ os.stat() does.
+ """
+ return os.stat(self, follow_symlinks=follow_symlinks)
+
+ def lstat(self):
+ """
+ Like stat(), except if the path points to a symlink, the symlink's
+ status information is returned, rather than its target's.
+ """
+ return self.stat(follow_symlinks=False)
+
+
+ # Convenience functions for querying the stat results
+
+ def exists(self, *, follow_symlinks=True):
+ """
+ Whether this path exists.
+
+ This method normally follows symlinks; to check whether a symlink exists,
+ add the argument follow_symlinks=False.
+ """
+ try:
+ self.stat(follow_symlinks=follow_symlinks)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+ return True
+
+ def is_dir(self):
+ """
+ Whether this path is a directory.
+ """
+ try:
+ return S_ISDIR(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_file(self):
+ """
+ Whether this path is a regular file (also True for symlinks pointing
+ to regular files).
+ """
+ try:
+ return S_ISREG(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_mount(self):
+ """
+ Check if this path is a mount point
+ """
+ return self._flavour.ismount(self)
+
+ def is_symlink(self):
+ """
+ Whether this path is a symbolic link.
+ """
+ try:
+ return S_ISLNK(self.lstat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_junction(self):
+ """
+ Whether this path is a junction.
+ """
+ return self._flavour.isjunction(self)
+
+ def is_block_device(self):
+ """
+ Whether this path is a block device.
+ """
+ try:
+ return S_ISBLK(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_char_device(self):
+ """
+ Whether this path is a character device.
+ """
+ try:
+ return S_ISCHR(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_fifo(self):
+ """
+ Whether this path is a FIFO.
+ """
+ try:
+ return S_ISFIFO(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def is_socket(self):
+ """
+ Whether this path is a socket.
+ """
+ try:
+ return S_ISSOCK(self.stat().st_mode)
+ except OSError as e:
+ if not _ignore_error(e):
+ raise
+ # Path doesn't exist or is a broken symlink
+ # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+ return False
+ except ValueError:
+ # Non-encodable path
+ return False
+
+ def samefile(self, other_path):
+ """Return whether other_path is the same or not as this file
+ (as returned by os.path.samefile()).
+ """
+ st = self.stat()
+ try:
+ other_st = other_path.stat()
+ except AttributeError:
+ other_st = self.with_segments(other_path).stat()
+ return self._flavour.samestat(st, other_st)
+
+ def open(self, mode='r', buffering=-1, encoding=None,
+ errors=None, newline=None):
+ """
+ Open the file pointed by this path and return a file object, as
+ the built-in open() function does.
+ """
+ if "b" not in mode:
+ encoding = io.text_encoding(encoding)
+ return io.open(self, mode, buffering, encoding, errors, newline)
+
+ def read_bytes(self):
+ """
+ Open the file in bytes mode, read it, and close the file.
+ """
+ with self.open(mode='rb') as f:
+ return f.read()
+
+ def read_text(self, encoding=None, errors=None):
+ """
+ Open the file in text mode, read it, and close the file.
+ """
+ encoding = io.text_encoding(encoding)
+ with self.open(mode='r', encoding=encoding, errors=errors) as f:
+ return f.read()
+
+ def write_bytes(self, data):
+ """
+ Open the file in bytes mode, write to it, and close the file.
+ """
+ # type-check for the buffer interface before truncating the file
+ view = memoryview(data)
+ with self.open(mode='wb') as f:
+ return f.write(view)
+
+ def write_text(self, data, encoding=None, errors=None, newline=None):
+ """
+ Open the file in text mode, write to it, and close the file.
+ """
+ if not isinstance(data, str):
+ raise TypeError('data must be str, not %s' %
+ data.__class__.__name__)
+ encoding = io.text_encoding(encoding)
+ with self.open(mode='w', encoding=encoding, errors=errors, newline=newline) as f:
+ return f.write(data)
+
+ def iterdir(self):
+ """Yield path objects of the directory contents.
+
+ The children are yielded in arbitrary order, and the
+ special entries '.' and '..' are not included.
+ """
+ for name in os.listdir(self):
+ yield self._make_child_relpath(name)
+
+ def _scandir(self):
+ # bpo-24132: a future version of pathlib will support subclassing of
+ # pathlib.Path to customize how the filesystem is accessed. This
+ # includes scandir(), which is used to implement glob().
+ return os.scandir(self)
+
+ def _make_child_relpath(self, name):
+ path_str = str(self)
+ tail = self._tail
+ if tail:
+ path_str = f'{path_str}{self._flavour.sep}{name}'
+ elif path_str != '.':
+ path_str = f'{path_str}{name}'
+ else:
+ path_str = name
+ path = self.with_segments(path_str)
+ path._str = path_str
+ path._drv = self.drive
+ path._root = self.root
+ path._tail_cached = tail + [name]
+ return path
+
+ def glob(self, pattern, *, case_sensitive=None):
+ """Iterate over this subtree and yield all existing files (of any
+ kind, including directories) matching the given relative pattern.
+ """
+ sys.audit("pathlib.Path.glob", self, pattern)
+ if not pattern:
+ raise ValueError("Unacceptable pattern: {!r}".format(pattern))
+ drv, root, pattern_parts = self._parse_path(pattern)
+ if drv or root:
+ raise NotImplementedError("Non-relative patterns are unsupported")
+ if pattern[-1] in (self._flavour.sep, self._flavour.altsep):
+ pattern_parts.append('')
+ selector = _make_selector(tuple(pattern_parts), self._flavour, case_sensitive)
+ for p in selector.select_from(self):
+ yield p
+
+ def rglob(self, pattern, *, case_sensitive=None):
+ """Recursively yield all existing files (of any kind, including
+ directories) matching the given relative pattern, anywhere in
+ this subtree.
+ """
+ sys.audit("pathlib.Path.rglob", self, pattern)
+ drv, root, pattern_parts = self._parse_path(pattern)
+ if drv or root:
+ raise NotImplementedError("Non-relative patterns are unsupported")
+ if pattern and pattern[-1] in (self._flavour.sep, self._flavour.altsep):
+ pattern_parts.append('')
+ selector = _make_selector(("**",) + tuple(pattern_parts), self._flavour, case_sensitive)
+ for p in selector.select_from(self):
+ yield p
+
+ def walk(self, top_down=True, on_error=None, follow_symlinks=False):
+ """Walk the directory tree from this directory, similar to os.walk()."""
+ sys.audit("pathlib.Path.walk", self, on_error, follow_symlinks)
+ paths = [self]
+
+ while paths:
+ path = paths.pop()
+ if isinstance(path, tuple):
+ yield path
+ continue
+
+ # We may not have read permission for self, in which case we can't
+ # get a list of the files the directory contains. os.walk()
+ # always suppressed the exception in that instance, rather than
+ # blow up for a minor reason when (say) a thousand readable
+ # directories are still left to visit. That logic is copied here.
+ try:
+ scandir_it = path._scandir()
+ except OSError as error:
+ if on_error is not None:
+ on_error(error)
+ continue
+
+ with scandir_it:
+ dirnames = []
+ filenames = []
+ for entry in scandir_it:
+ try:
+ is_dir = entry.is_dir(follow_symlinks=follow_symlinks)
+ except OSError:
+ # Carried over from os.path.isdir().
+ is_dir = False
+
+ if is_dir:
+ dirnames.append(entry.name)
+ else:
+ filenames.append(entry.name)
+
+ if top_down:
+ yield path, dirnames, filenames
+ else:
+ paths.append((path, dirnames, filenames))
+
+ paths += [path._make_child_relpath(d) for d in reversed(dirnames)]
+
+ def __init__(self, *args, **kwargs):
+ if kwargs:
+ msg = ("support for supplying keyword arguments to pathlib.PurePath "
+ "is deprecated and scheduled for removal in Python {remove}")
+ warnings._deprecated("pathlib.PurePath(**kwargs)", msg, remove=(3, 14))
+ super().__init__(*args)
+
+ def __new__(cls, *args, **kwargs):
+ if cls is Path:
+ cls = WindowsPath if os.name == 'nt' else PosixPath
+ return object.__new__(cls)
+
+ def __enter__(self):
+ # In previous versions of pathlib, __exit__() marked this path as
+ # closed; subsequent attempts to perform I/O would raise an IOError.
+ # This functionality was never documented, and had the effect of
+ # making Path objects mutable, contrary to PEP 428.
+ # In Python 3.9 __exit__() was made a no-op.
+ # In Python 3.11 __enter__() began emitting DeprecationWarning.
+ # In Python 3.13 __enter__() and __exit__() should be removed.
+ warnings.warn("pathlib.Path.__enter__() is deprecated and scheduled "
+ "for removal in Python 3.13; Path objects as a context "
+ "manager is a no-op",
+ DeprecationWarning, stacklevel=2)
+ return self
+
+ def __exit__(self, t, v, tb):
+ pass
+
+ # Public API
+
+ @classmethod
+ def cwd(cls):
+ """Return a new path pointing to the current working directory."""
+ # We call 'absolute()' rather than using 'os.getcwd()' directly to
+ # enable users to replace the implementation of 'absolute()' in a
+ # subclass and benefit from the new behaviour here. This works because
+ # os.path.abspath('.') == os.getcwd().
+ return cls().absolute()
+
+ @classmethod
+ def home(cls):
+ """Return a new path pointing to the user's home directory (as
+ returned by os.path.expanduser('~')).
+ """
+ return cls("~").expanduser()
+
+ def absolute(self):
+ """Return an absolute version of this path by prepending the current
+ working directory. No normalization or symlink resolution is performed.
+
+ Use resolve() to get the canonical path to a file.
+ """
+ if self.is_absolute():
+ return self
+ elif self.drive:
+ # There is a CWD on each drive-letter drive.
+ cwd = self._flavour.abspath(self.drive)
+ else:
+ cwd = os.getcwd()
+ # Fast path for "empty" paths, e.g. Path("."), Path("") or Path().
+ # We pass only one argument to with_segments() to avoid the cost
+ # of joining, and we exploit the fact that getcwd() returns a
+ # fully-normalized string by storing it in _str. This is used to
+ # implement Path.cwd().
+ if not self.root and not self._tail:
+ result = self.with_segments(cwd)
+ result._str = cwd
+ return result
+ return self.with_segments(cwd, self)
+
+ def resolve(self, strict=False):
+ """
+ Make the path absolute, resolving all symlinks on the way and also
+ normalizing it.
+ """
+
+ def check_eloop(e):
+ winerror = getattr(e, 'winerror', 0)
+ if e.errno == ELOOP or winerror == _WINERROR_CANT_RESOLVE_FILENAME:
+ raise RuntimeError("Symlink loop from %r" % e.filename)
+
+ try:
+ s = self._flavour.realpath(self, strict=strict)
+ except OSError as e:
+ check_eloop(e)
+ raise
+ p = self.with_segments(s)
+
+ # In non-strict mode, realpath() doesn't raise on symlink loops.
+ # Ensure we get an exception by calling stat()
+ if not strict:
+ try:
+ p.stat()
+ except OSError as e:
+ check_eloop(e)
+ return p
+
+ def owner(self):
+ """
+ Return the login name of the file owner.
+ """
+ try:
+ import pwd
+ return pwd.getpwuid(self.stat().st_uid).pw_name
+ except ImportError:
+ raise NotImplementedError("Path.owner() is unsupported on this system")
+
+ def group(self):
+ """
+ Return the group name of the file gid.
+ """
+
+ try:
+ import grp
+ return grp.getgrgid(self.stat().st_gid).gr_name
+ except ImportError:
+ raise NotImplementedError("Path.group() is unsupported on this system")
+
+ def readlink(self):
+ """
+ Return the path to which the symbolic link points.
+ """
+ if not hasattr(os, "readlink"):
+ raise NotImplementedError("os.readlink() not available on this system")
+ return self.with_segments(os.readlink(self))
+
+ def touch(self, mode=0o666, exist_ok=True):
+ """
+ Create this file with the given access mode, if it doesn't exist.
+ """
+
+ if exist_ok:
+ # First try to bump modification time
+ # Implementation note: GNU touch uses the UTIME_NOW option of
+ # the utimensat() / futimens() functions.
+ try:
+ os.utime(self, None)
+ except OSError:
+ # Avoid exception chaining
+ pass
+ else:
+ return
+ flags = os.O_CREAT | os.O_WRONLY
+ if not exist_ok:
+ flags |= os.O_EXCL
+ fd = os.open(self, flags, mode)
+ os.close(fd)
+
+ def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+ """
+ Create a new directory at this given path.
+ """
+ try:
+ os.mkdir(self, mode)
+ except FileNotFoundError:
+ if not parents or self.parent == self:
+ raise
+ self.parent.mkdir(parents=True, exist_ok=True)
+ self.mkdir(mode, parents=False, exist_ok=exist_ok)
+ except OSError:
+ # Cannot rely on checking for EEXIST, since the operating system
+ # could give priority to other errors like EACCES or EROFS
+ if not exist_ok or not self.is_dir():
+ raise
+
+ def chmod(self, mode, *, follow_symlinks=True):
+ """
+ Change the permissions of the path, like os.chmod().
+ """
+ os.chmod(self, mode, follow_symlinks=follow_symlinks)
+
+ def lchmod(self, mode):
+ """
+ Like chmod(), except if the path points to a symlink, the symlink's
+ permissions are changed, rather than its target's.
+ """
+ self.chmod(mode, follow_symlinks=False)
+
+ def unlink(self, missing_ok=False):
+ """
+ Remove this file or link.
+ If the path is a directory, use rmdir() instead.
+ """
+ try:
+ os.unlink(self)
+ except FileNotFoundError:
+ if not missing_ok:
+ raise
+
+ def rmdir(self):
+ """
+ Remove this directory. The directory must be empty.
+ """
+ os.rmdir(self)
+
+ def rename(self, target):
+ """
+ Rename this path to the target path.
+
+ The target path may be absolute or relative. Relative paths are
+ interpreted relative to the current working directory, *not* the
+ directory of the Path object.
+
+ Returns the new Path instance pointing to the target path.
+ """
+ os.rename(self, target)
+ return self.with_segments(target)
+
+ def replace(self, target):
+ """
+ Rename this path to the target path, overwriting if that path exists.
+
+ The target path may be absolute or relative. Relative paths are
+ interpreted relative to the current working directory, *not* the
+ directory of the Path object.
+
+ Returns the new Path instance pointing to the target path.
+ """
+ os.replace(self, target)
+ return self.with_segments(target)
+
+ def symlink_to(self, target, target_is_directory=False):
+ """
+ Make this path a symlink pointing to the target path.
+ Note the order of arguments (link, target) is the reverse of os.symlink.
+ """
+ if not hasattr(os, "symlink"):
+ raise NotImplementedError("os.symlink() not available on this system")
+ os.symlink(target, self, target_is_directory)
+
+ def hardlink_to(self, target):
+ """
+ Make this path a hard link pointing to the same file as *target*.
+
+ Note the order of arguments (self, target) is the reverse of os.link's.
+ """
+ if not hasattr(os, "link"):
+ raise NotImplementedError("os.link() not available on this system")
+ os.link(target, self)
+
+ def expanduser(self):
+ """ Return a new path with expanded ~ and ~user constructs
+ (as returned by os.path.expanduser)
+ """
+ if (not (self.drive or self.root) and
+ self._tail and self._tail[0][:1] == '~'):
+ homedir = self._flavour.expanduser(self._tail[0])
+ if homedir[:1] == "~":
+ raise RuntimeError("Could not determine home directory.")
+ drv, root, tail = self._parse_path(homedir)
+ return self._from_parsed_parts(drv, root, tail + self._tail[1:])
+
+ return self
+
|
{width="2.13in"
+ height="2.9in"}
{width="2.13in"
+ height="2.9in"}