Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

""" 

""" 

import warnings 

import os 

import sys 

import posixpath 

import fnmatch 

import py 

 

# Moved from local.py. 

iswin32 = sys.platform == "win32" or (getattr(os, '_name', False) == 'nt') 

 

try: 

from os import fspath 

except ImportError: 

def fspath(path): 

""" 

Return the string representation of the path. 

If str or bytes is passed in, it is returned unchanged. 

This code comes from PEP 519, modified to support earlier versions of 

python. 

 

This is required for python < 3.6. 

""" 

if isinstance(path, (py.builtin.text, py.builtin.bytes)): 

return path 

 

# Work from the object's type to match method resolution of other magic 

# methods. 

path_type = type(path) 

try: 

return path_type.__fspath__(path) 

except AttributeError: 

if hasattr(path_type, '__fspath__'): 

raise 

try: 

import pathlib 

except ImportError: 

pass 

else: 

if isinstance(path, pathlib.PurePath): 

return py.builtin.text(path) 

 

raise TypeError("expected str, bytes or os.PathLike object, not " 

+ path_type.__name__) 

 

class Checkers: 

_depend_on_existence = 'exists', 'link', 'dir', 'file' 

 

def __init__(self, path): 

self.path = path 

 

def dir(self): 

raise NotImplementedError 

 

def file(self): 

raise NotImplementedError 

 

def dotfile(self): 

return self.path.basename.startswith('.') 

 

def ext(self, arg): 

if not arg.startswith('.'): 

arg = '.' + arg 

return self.path.ext == arg 

 

def exists(self): 

raise NotImplementedError 

 

def basename(self, arg): 

return self.path.basename == arg 

 

def basestarts(self, arg): 

return self.path.basename.startswith(arg) 

 

def relto(self, arg): 

return self.path.relto(arg) 

 

def fnmatch(self, arg): 

return self.path.fnmatch(arg) 

 

def endswith(self, arg): 

return str(self.path).endswith(arg) 

 

def _evaluate(self, kw): 

for name, value in kw.items(): 

invert = False 

meth = None 

try: 

meth = getattr(self, name) 

except AttributeError: 

if name[:3] == 'not': 

invert = True 

try: 

meth = getattr(self, name[3:]) 

except AttributeError: 

pass 

if meth is None: 

raise TypeError( 

"no %r checker available for %r" % (name, self.path)) 

try: 

if py.code.getrawcode(meth).co_argcount > 1: 

if (not meth(value)) ^ invert: 

return False 

else: 

if bool(value) ^ bool(meth()) ^ invert: 

return False 

except (py.error.ENOENT, py.error.ENOTDIR, py.error.EBUSY): 

# EBUSY feels not entirely correct, 

# but its kind of necessary since ENOMEDIUM 

# is not accessible in python 

for name in self._depend_on_existence: 

if name in kw: 

if kw.get(name): 

return False 

name = 'not' + name 

if name in kw: 

if not kw.get(name): 

return False 

return True 

 

class NeverRaised(Exception): 

pass 

 

class PathBase(object): 

""" shared implementation for filesystem path objects.""" 

Checkers = Checkers 

 

def __div__(self, other): 

return self.join(fspath(other)) 

__truediv__ = __div__ # py3k 

 

def basename(self): 

""" basename part of path. """ 

return self._getbyspec('basename')[0] 

basename = property(basename, None, None, basename.__doc__) 

 

def dirname(self): 

""" dirname part of path. """ 

return self._getbyspec('dirname')[0] 

dirname = property(dirname, None, None, dirname.__doc__) 

 

def purebasename(self): 

""" pure base name of the path.""" 

return self._getbyspec('purebasename')[0] 

purebasename = property(purebasename, None, None, purebasename.__doc__) 

 

def ext(self): 

""" extension of the path (including the '.').""" 

return self._getbyspec('ext')[0] 

ext = property(ext, None, None, ext.__doc__) 

 

def dirpath(self, *args, **kwargs): 

""" return the directory path joined with any given path arguments. """ 

return self.new(basename='').join(*args, **kwargs) 

 

def read_binary(self): 

""" read and return a bytestring from reading the path. """ 

with self.open('rb') as f: 

return f.read() 

 

def read_text(self, encoding): 

""" read and return a Unicode string from reading the path. """ 

with self.open("r", encoding=encoding) as f: 

return f.read() 

 

 

def read(self, mode='r'): 

""" read and return a bytestring from reading the path. """ 

with self.open(mode) as f: 

return f.read() 

 

def readlines(self, cr=1): 

""" read and return a list of lines from the path. if cr is False, the 

newline will be removed from the end of each line. """ 

if sys.version_info < (3, ): 

mode = 'rU' 

else: # python 3 deprecates mode "U" in favor of "newline" option 

mode = 'r' 

 

if not cr: 

content = self.read(mode) 

return content.split('\n') 

else: 

f = self.open(mode) 

try: 

return f.readlines() 

finally: 

f.close() 

 

def load(self): 

""" (deprecated) return object unpickled from self.read() """ 

f = self.open('rb') 

try: 

import pickle 

return py.error.checked_call(pickle.load, f) 

finally: 

f.close() 

 

def move(self, target): 

""" move this path to target. """ 

if target.relto(self): 

raise py.error.EINVAL( 

target, 

"cannot move path into a subdirectory of itself") 

try: 

self.rename(target) 

except py.error.EXDEV: # invalid cross-device link 

self.copy(target) 

self.remove() 

 

def __repr__(self): 

""" return a string representation of this path. """ 

return repr(str(self)) 

 

def check(self, **kw): 

""" check a path for existence and properties. 

 

Without arguments, return True if the path exists, otherwise False. 

 

valid checkers:: 

 

file=1 # is a file 

file=0 # is not a file (may not even exist) 

dir=1 # is a dir 

link=1 # is a link 

exists=1 # exists 

 

You can specify multiple checker definitions, for example:: 

 

path.check(file=1, link=1) # a link pointing to a file 

""" 

if not kw: 

kw = {'exists': 1} 

return self.Checkers(self)._evaluate(kw) 

 

def fnmatch(self, pattern): 

"""return true if the basename/fullname matches the glob-'pattern'. 

 

valid pattern characters:: 

 

* matches everything 

? matches any single character 

[seq] matches any character in seq 

[!seq] matches any char not in seq 

 

If the pattern contains a path-separator then the full path 

is used for pattern matching and a '*' is prepended to the 

pattern. 

 

if the pattern doesn't contain a path-separator the pattern 

is only matched against the basename. 

""" 

return FNMatcher(pattern)(self) 

 

def relto(self, relpath): 

""" return a string which is the relative part of the path 

to the given 'relpath'. 

""" 

if not isinstance(relpath, (str, PathBase)): 

raise TypeError("%r: not a string or path object" %(relpath,)) 

strrelpath = str(relpath) 

if strrelpath and strrelpath[-1] != self.sep: 

strrelpath += self.sep 

#assert strrelpath[-1] == self.sep 

#assert strrelpath[-2] != self.sep 

strself = self.strpath 

if sys.platform == "win32" or getattr(os, '_name', None) == 'nt': 

if os.path.normcase(strself).startswith( 

os.path.normcase(strrelpath)): 

return strself[len(strrelpath):] 

elif strself.startswith(strrelpath): 

return strself[len(strrelpath):] 

return "" 

 

def ensure_dir(self, *args): 

""" ensure the path joined with args is a directory. """ 

return self.ensure(*args, **{"dir": True}) 

 

def bestrelpath(self, dest): 

""" return a string which is a relative path from self 

(assumed to be a directory) to dest such that 

self.join(bestrelpath) == dest and if not such 

path can be determined return dest. 

""" 

try: 

if self == dest: 

return os.curdir 

base = self.common(dest) 

if not base: # can be the case on windows 

return str(dest) 

self2base = self.relto(base) 

reldest = dest.relto(base) 

if self2base: 

n = self2base.count(self.sep) + 1 

else: 

n = 0 

l = [os.pardir] * n 

if reldest: 

l.append(reldest) 

target = dest.sep.join(l) 

return target 

except AttributeError: 

return str(dest) 

 

def exists(self): 

return self.check() 

 

def isdir(self): 

return self.check(dir=1) 

 

def isfile(self): 

return self.check(file=1) 

 

def parts(self, reverse=False): 

""" return a root-first list of all ancestor directories 

plus the path itself. 

""" 

current = self 

l = [self] 

while 1: 

last = current 

current = current.dirpath() 

if last == current: 

break 

l.append(current) 

if not reverse: 

l.reverse() 

return l 

 

def common(self, other): 

""" return the common part shared with the other path 

or None if there is no common part. 

""" 

last = None 

for x, y in zip(self.parts(), other.parts()): 

if x != y: 

return last 

last = x 

return last 

 

def __add__(self, other): 

""" return new path object with 'other' added to the basename""" 

return self.new(basename=self.basename+str(other)) 

 

def __cmp__(self, other): 

""" return sort value (-1, 0, +1). """ 

try: 

return cmp(self.strpath, other.strpath) 

except AttributeError: 

return cmp(str(self), str(other)) # self.path, other.path) 

 

def __lt__(self, other): 

try: 

return self.strpath < other.strpath 

except AttributeError: 

return str(self) < str(other) 

 

def visit(self, fil=None, rec=None, ignore=NeverRaised, bf=False, sort=False): 

""" yields all paths below the current one 

 

fil is a filter (glob pattern or callable), if not matching the 

path will not be yielded, defaulting to None (everything is 

returned) 

 

rec is a filter (glob pattern or callable) that controls whether 

a node is descended, defaulting to None 

 

ignore is an Exception class that is ignoredwhen calling dirlist() 

on any of the paths (by default, all exceptions are reported) 

 

bf if True will cause a breadthfirst search instead of the 

default depthfirst. Default: False 

 

sort if True will sort entries within each directory level. 

""" 

for x in Visitor(fil, rec, ignore, bf, sort).gen(self): 

yield x 

 

def _sortlist(self, res, sort): 

if sort: 

if hasattr(sort, '__call__'): 

warnings.warn(DeprecationWarning( 

"listdir(sort=callable) is deprecated and breaks on python3" 

), stacklevel=3) 

res.sort(sort) 

else: 

res.sort() 

 

def samefile(self, other): 

""" return True if other refers to the same stat object as self. """ 

return self.strpath == str(other) 

 

def __fspath__(self): 

return self.strpath 

 

class Visitor: 

def __init__(self, fil, rec, ignore, bf, sort): 

if isinstance(fil, py.builtin._basestring): 

fil = FNMatcher(fil) 

if isinstance(rec, py.builtin._basestring): 

self.rec = FNMatcher(rec) 

elif not hasattr(rec, '__call__') and rec: 

self.rec = lambda path: True 

else: 

self.rec = rec 

self.fil = fil 

self.ignore = ignore 

self.breadthfirst = bf 

self.optsort = sort and sorted or (lambda x: x) 

 

def gen(self, path): 

try: 

entries = path.listdir() 

except self.ignore: 

return 

rec = self.rec 

dirs = self.optsort([p for p in entries 

if p.check(dir=1) and (rec is None or rec(p))]) 

if not self.breadthfirst: 

for subdir in dirs: 

for p in self.gen(subdir): 

yield p 

for p in self.optsort(entries): 

if self.fil is None or self.fil(p): 

yield p 

if self.breadthfirst: 

for subdir in dirs: 

for p in self.gen(subdir): 

yield p 

 

class FNMatcher: 

def __init__(self, pattern): 

self.pattern = pattern 

 

def __call__(self, path): 

pattern = self.pattern 

 

if (pattern.find(path.sep) == -1 and 

iswin32 and 

pattern.find(posixpath.sep) != -1): 

# Running on Windows, the pattern has no Windows path separators, 

# and the pattern has one or more Posix path separators. Replace 

# the Posix path separators with the Windows path separator. 

pattern = pattern.replace(posixpath.sep, path.sep) 

 

if pattern.find(path.sep) == -1: 

name = path.basename 

else: 

name = str(path) # path.strpath # XXX svn? 

if not os.path.isabs(pattern): 

pattern = '*' + path.sep + pattern 

return fnmatch.fnmatch(name, pattern)