Lines Matching refs:self
374 def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
375 self.orig_filename = filename # Original file name in archive
388 self.filename = filename # Normalized file name
389 self.date_time = date_time # year, month, day, hour, min, sec
395 self.compress_type = ZIP_STORED # Type of compression for the file
396 self._compresslevel = None # Level for the compressor
397 self.comment = b"" # Comment for each file
398 self.extra = b"" # ZIP extra data
400 self.create_system = 0 # System which created ZIP archive
403 self.create_system = 3 # System which created ZIP archive
404 self.create_version = DEFAULT_VERSION # Version which created ZIP archive
405 self.extract_version = DEFAULT_VERSION # Version needed to extract archive
406 self.reserved = 0 # Must be zero
407 self.flag_bits = 0 # ZIP flag bits
408 self.volume = 0 # Volume number of file header
409 self.internal_attr = 0 # Internal attributes
410 self.external_attr = 0 # External file attributes
411 self.compress_size = 0 # Size of the compressed file
412 self.file_size = 0 # Size of the uncompressed file
413 self._end_offset = None # Start of the next local header or central directory
418 def __repr__(self):
419 result = ['<%s filename=%r' % (self.__class__.__name__, self.filename)]
420 if self.compress_type != ZIP_STORED:
422 compressor_names.get(self.compress_type,
423 self.compress_type))
424 hi = self.external_attr >> 16
425 lo = self.external_attr & 0xFFFF
430 isdir = self.is_dir()
431 if not isdir or self.file_size:
432 result.append(' file_size=%r' % self.file_size)
433 if ((not isdir or self.compress_size) and
434 (self.compress_type != ZIP_STORED or
435 self.file_size != self.compress_size)):
436 result.append(' compress_size=%r' % self.compress_size)
440 def FileHeader(self, zip64=None):
447 dt = self.date_time
450 if self.flag_bits & _MASK_USE_DATA_DESCRIPTOR:
454 CRC = self.CRC
455 compress_size = self.compress_size
456 file_size = self.file_size
458 extra = self.extra
473 if self.compress_type == ZIP_BZIP2:
475 elif self.compress_type == ZIP_LZMA:
478 self.extract_version = max(min_version, self.extract_version)
479 self.create_version = max(min_version, self.create_version)
480 filename, flag_bits = self._encodeFilenameFlags()
482 self.extract_version, self.reserved, flag_bits,
483 self.compress_type, dostime, dosdate, CRC,
488 def _encodeFilenameFlags(self):
490 return self.filename.encode('ascii'), self.flag_bits
492 return self.filename.encode('utf-8'), self.flag_bits | _MASK_UTF_FILENAME
494 def _decodeExtra(self):
496 extra = self.extra
506 if self.file_size in (0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF):
508 self.file_size, = unpack('<Q', data[:8])
510 if self.compress_size == 0xFFFF_FFFF:
512 self.compress_size, = unpack('<Q', data[:8])
514 if self.header_offset == 0xFFFF_FFFF:
516 self.header_offset, = unpack('<Q', data[:8])
561 def is_dir(self):
563 return self.filename[-1] == '/'
627 def __init__(self):
628 self._comp = None
630 def _init(self):
632 self._comp = lzma.LZMACompressor(lzma.FORMAT_RAW, filters=[
637 def compress(self, data):
638 if self._comp is None:
639 return self._init() + self._comp.compress(data)
640 return self._comp.compress(data)
642 def flush(self):
643 if self._comp is None:
644 return self._init() + self._comp.flush()
645 return self._comp.flush()
650 def __init__(self):
651 self._decomp = None
652 self._unconsumed = b''
653 self.eof = False
655 def decompress(self, data):
656 if self._decomp is None:
657 self._unconsumed += data
658 if len(self._unconsumed) <= 4:
660 psize, = struct.unpack('<H', self._unconsumed[2:4])
661 if len(self._unconsumed) <= 4 + psize:
664 self._decomp = lzma.LZMADecompressor(lzma.FORMAT_RAW, filters=[
666 self._unconsumed[4:4 + psize])
668 data = self._unconsumed[4 + psize:]
669 del self._unconsumed
671 result = self._decomp.decompress(data)
672 self.eof = self._decomp.eof
750 def __init__(self, file, pos, close, lock, writing):
751 self._file = file
752 self._pos = pos
753 self._close = close
754 self._lock = lock
755 self._writing = writing
756 self.seekable = file.seekable
758 def tell(self):
759 return self._pos
761 def seek(self, offset, whence=0):
762 with self._lock:
763 if self._writing():
767 self._file.seek(offset, whence)
768 self._pos = self._file.tell()
769 return self._pos
771 def read(self, n=-1):
772 with self._lock:
773 if self._writing():
777 self._file.seek(self._pos)
778 data = self._file.read(n)
779 self._pos = self._file.tell()
782 def close(self):
783 if self._file is not None:
784 fileobj = self._file
785 self._file = None
786 self._close(fileobj)
790 def __init__(self, fp):
791 self.fp = fp
792 self.offset = 0
794 def write(self, data):
795 n = self.fp.write(data)
796 self.offset += n
799 def tell(self):
800 return self.offset
802 def flush(self):
803 self.fp.flush()
805 def close(self):
806 self.fp.close()
823 def __init__(self, fileobj, mode, zipinfo, pwd=None,
825 self._fileobj = fileobj
826 self._pwd = pwd
827 self._close_fileobj = close_fileobj
829 self._compress_type = zipinfo.compress_type
830 self._compress_left = zipinfo.compress_size
831 self._left = zipinfo.file_size
833 self._decompressor = _get_decompressor(self._compress_type)
835 self._eof = False
836 self._readbuffer = b''
837 self._offset = 0
839 self.newlines = None
841 self.mode = mode
842 self.name = zipinfo.filename
845 self._expected_crc = zipinfo.CRC
846 self._running_crc = crc32(b'')
848 self._expected_crc = None
850 self._seekable = False
853 self._orig_compress_start = fileobj.tell()
854 self._orig_compress_size = zipinfo.compress_size
855 self._orig_file_size = zipinfo.file_size
856 self._orig_start_crc = self._running_crc
857 self._seekable = True
861 self._decrypter = None
869 h = self._init_decrypter()
874 def _init_decrypter(self):
875 self._decrypter = _ZipDecrypter(self._pwd)
881 header = self._fileobj.read(12)
882 self._compress_left -= 12
883 return self._decrypter(header)[11]
885 def __repr__(self):
886 result = ['<%s.%s' % (self.__class__.__module__,
887 self.__class__.__qualname__)]
888 if not self.closed:
889 result.append(' name=%r mode=%r' % (self.name, self.mode))
890 if self._compress_type != ZIP_STORED:
892 compressor_names.get(self._compress_type,
893 self._compress_type))
899 def readline(self, limit=-1):
907 i = self._readbuffer.find(b'\n', self._offset) + 1
909 line = self._readbuffer[self._offset: i]
910 self._offset = i
913 return io.BufferedIOBase.readline(self, limit)
915 def peek(self, n=1):
917 if n > len(self._readbuffer) - self._offset:
918 chunk = self.read(n)
919 if len(chunk) > self._offset:
920 self._readbuffer = chunk + self._readbuffer[self._offset:]
921 self._offset = 0
923 self._offset -= len(chunk)
926 return self._readbuffer[self._offset: self._offset + 512]
928 def readable(self):
929 if self.closed:
933 def read(self, n=-1):
937 if self.closed:
940 buf = self._readbuffer[self._offset:]
941 self._readbuffer = b''
942 self._offset = 0
943 while not self._eof:
944 buf += self._read1(self.MAX_N)
947 end = n + self._offset
948 if end < len(self._readbuffer):
949 buf = self._readbuffer[self._offset:end]
950 self._offset = end
953 n = end - len(self._readbuffer)
954 buf = self._readbuffer[self._offset:]
955 self._readbuffer = b''
956 self._offset = 0
957 while n > 0 and not self._eof:
958 data = self._read1(n)
960 self._readbuffer = data
961 self._offset = n
968 def _update_crc(self, newdata):
970 if self._expected_crc is None:
973 self._running_crc = crc32(newdata, self._running_crc)
975 if self._eof and self._running_crc != self._expected_crc:
976 raise BadZipFile("Bad CRC-32 for file %r" % self.name)
978 def read1(self, n):
982 buf = self._readbuffer[self._offset:]
983 self._readbuffer = b''
984 self._offset = 0
985 while not self._eof:
986 data = self._read1(self.MAX_N)
992 end = n + self._offset
993 if end < len(self._readbuffer):
994 buf = self._readbuffer[self._offset:end]
995 self._offset = end
998 n = end - len(self._readbuffer)
999 buf = self._readbuffer[self._offset:]
1000 self._readbuffer = b''
1001 self._offset = 0
1003 while not self._eof:
1004 data = self._read1(n)
1006 self._readbuffer = data
1007 self._offset = n
1015 def _read1(self, n):
1018 if self._eof or n <= 0:
1022 if self._compress_type == ZIP_DEFLATED:
1024 data = self._decompressor.unconsumed_tail
1026 data += self._read2(n - len(data))
1028 data = self._read2(n)
1030 if self._compress_type == ZIP_STORED:
1031 self._eof = self._compress_left <= 0
1032 elif self._compress_type == ZIP_DEFLATED:
1033 n = max(n, self.MIN_READ_SIZE)
1034 data = self._decompressor.decompress(data, n)
1035 self._eof = (self._decompressor.eof or
1036 self._compress_left <= 0 and
1037 not self._decompressor.unconsumed_tail)
1038 if self._eof:
1039 data += self._decompressor.flush()
1041 data = self._decompressor.decompress(data)
1042 self._eof = self._decompressor.eof or self._compress_left <= 0
1044 data = data[:self._left]
1045 self._left -= len(data)
1046 if self._left <= 0:
1047 self._eof = True
1048 self._update_crc(data)
1051 def _read2(self, n):
1052 if self._compress_left <= 0:
1055 n = max(n, self.MIN_READ_SIZE)
1056 n = min(n, self._compress_left)
1058 data = self._fileobj.read(n)
1059 self._compress_left -= len(data)
1063 if self._decrypter is not None:
1064 data = self._decrypter(data)
1067 def close(self):
1069 if self._close_fileobj:
1070 self._fileobj.close()
1074 def seekable(self):
1075 if self.closed:
1077 return self._seekable
1079 def seek(self, offset, whence=0):
1080 if self.closed:
1082 if not self._seekable:
1084 curr_pos = self.tell()
1090 new_pos = self._orig_file_size + offset
1095 if new_pos > self._orig_file_size:
1096 new_pos = self._orig_file_size
1102 buff_offset = read_offset + self._offset
1104 if buff_offset >= 0 and buff_offset < len(self._readbuffer):
1106 self._offset = buff_offset
1110 self._fileobj.seek(self._orig_compress_start)
1111 self._running_crc = self._orig_start_crc
1112 self._compress_left = self._orig_compress_size
1113 self._left = self._orig_file_size
1114 self._readbuffer = b''
1115 self._offset = 0
1116 self._decompressor = _get_decompressor(self._compress_type)
1117 self._eof = False
1119 if self._decrypter is not None:
1120 self._init_decrypter()
1123 read_len = min(self.MAX_SEEK_READ, read_offset)
1124 self.read(read_len)
1127 return self.tell()
1129 def tell(self):
1130 if self.closed:
1132 if not self._seekable:
1134 filepos = self._orig_file_size - self._left - len(self._readbuffer) + self._offset
1139 def __init__(self, zf, zinfo, zip64):
1140 self._zinfo = zinfo
1141 self._zip64 = zip64
1142 self._zipfile = zf
1143 self._compressor = _get_compressor(zinfo.compress_type,
1145 self._file_size = 0
1146 self._compress_size = 0
1147 self._crc = 0
1150 def _fileobj(self):
1151 return self._zipfile.fp
1153 def writable(self):
1156 def write(self, data):
1157 if self.closed:
1166 self._file_size += nbytes
1168 self._crc = crc32(data, self._crc)
1169 if self._compressor:
1170 data = self._compressor.compress(data)
1171 self._compress_size += len(data)
1172 self._fileobj.write(data)
1175 def close(self):
1176 if self.closed:
1181 if self._compressor:
1182 buf = self._compressor.flush()
1183 self._compress_size += len(buf)
1184 self._fileobj.write(buf)
1185 self._zinfo.compress_size = self._compress_size
1187 self._zinfo.compress_size = self._file_size
1188 self._zinfo.CRC = self._crc
1189 self._zinfo.file_size = self._file_size
1191 if not self._zip64:
1192 if self._file_size > ZIP64_LIMIT:
1194 if self._compress_size > ZIP64_LIMIT:
1198 if self._zinfo.flag_bits & _MASK_USE_DATA_DESCRIPTOR:
1200 fmt = '<LLQQ' if self._zip64 else '<LLLL'
1201 self._fileobj.write(struct.pack(fmt, _DD_SIGNATURE, self._zinfo.CRC,
1202 self._zinfo.compress_size, self._zinfo.file_size))
1203 self._zipfile.start_dir = self._fileobj.tell()
1209 self._zipfile.start_dir = self._fileobj.tell()
1210 self._fileobj.seek(self._zinfo.header_offset)
1211 self._fileobj.write(self._zinfo.FileHeader(self._zip64))
1212 self._fileobj.seek(self._zipfile.start_dir)
1215 self._zipfile.filelist.append(self._zinfo)
1216 self._zipfile.NameToInfo[self._zinfo.filename] = self._zinfo
1218 self._zipfile._writing = False
1248 def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=True,
1257 self._allowZip64 = allowZip64
1258 self._didModify = False
1259 self.debug = 0 # Level of printing: 0 through 3
1260 self.NameToInfo = {} # Find file info given name
1261 self.filelist = [] # List of ZipInfo instances for archive
1262 self.compression = compression # Method of compression
1263 self.compresslevel = compresslevel
1264 self.mode = mode
1265 self.pwd = None
1266 self._comment = b''
1267 self._strict_timestamps = strict_timestamps
1268 self.metadata_encoding = metadata_encoding
1271 if self.metadata_encoding and mode != 'r':
1280 self._filePassed = 0
1281 self.filename = file
1287 self.fp = io.open(file, filemode)
1295 self._filePassed = 1
1296 self.fp = file
1297 self.filename = getattr(file, 'name', None)
1298 self._fileRefCnt = 1
1299 self._lock = threading.RLock()
1300 self._seekable = True
1301 self._writing = False
1305 self._RealGetContents()
1309 self._didModify = True
1311 self.start_dir = self.fp.tell()
1313 self.fp = _Tellable(self.fp)
1314 self.start_dir = 0
1315 self._seekable = False
1319 self.fp.seek(self.start_dir)
1321 self._seekable = False
1325 self._RealGetContents()
1327 self.fp.seek(self.start_dir)
1330 self.fp.seek(0, 2)
1334 self._didModify = True
1335 self.start_dir = self.fp.tell()
1339 fp = self.fp
1340 self.fp = None
1341 self._fpclose(fp)
1344 def __enter__(self):
1345 return self
1347 def __exit__(self, type, value, traceback):
1348 self.close()
1350 def __repr__(self):
1351 result = ['<%s.%s' % (self.__class__.__module__,
1352 self.__class__.__qualname__)]
1353 if self.fp is not None:
1354 if self._filePassed:
1355 result.append(' file=%r' % self.fp)
1356 elif self.filename is not None:
1357 result.append(' filename=%r' % self.filename)
1358 result.append(' mode=%r' % self.mode)
1364 def _RealGetContents(self):
1366 fp = self.fp
1373 if self.debug > 1:
1377 self._comment = endrec[_ECD_COMMENT] # archive comment
1385 if self.debug > 2:
1388 # self.start_dir: Position of start of central directory
1389 self.start_dir = offset_cd + concat
1390 if self.start_dir < 0:
1392 fp.seek(self.start_dir, 0)
1403 if self.debug > 2:
1412 filename = filename.decode(self.metadata_encoding or 'cp437')
1432 self.filelist.append(x)
1433 self.NameToInfo[x.filename] = x
1440 if self.debug > 2:
1443 end_offset = self.start_dir
1444 for zinfo in sorted(self.filelist,
1450 def namelist(self):
1452 return [data.filename for data in self.filelist]
1454 def infolist(self):
1457 return self.filelist
1459 def printdir(self, file=None):
1463 for zinfo in self.filelist:
1468 def testzip(self):
1471 for zinfo in self.filelist:
1475 with self.open(zinfo.filename, "r") as f:
1481 def getinfo(self, name):
1483 info = self.NameToInfo.get(name)
1490 def setpassword(self, pwd):
1495 self.pwd = pwd
1497 self.pwd = None
1500 def comment(self):
1502 return self._comment
1505 def comment(self, comment):
1514 self._comment = comment
1515 self._didModify = True
1517 def read(self, name, pwd=None):
1519 with self.open(name, "r", pwd) as fp:
1522 def open(self, name, mode="r", pwd=None, *, force_zip64=False):
1542 if not self.fp:
1552 zinfo.compress_type = self.compression
1553 zinfo._compresslevel = self.compresslevel
1556 zinfo = self.getinfo(name)
1559 return self._open_to_write(zinfo, force_zip64=force_zip64)
1561 if self._writing:
1567 self._fileRefCnt += 1
1568 zef_file = _SharedFile(self.fp, zinfo.header_offset,
1569 self._fpclose, self._lock, lambda: self._writing)
1595 fname_str = fname.decode(self.metadata_encoding or "cp437")
1610 pwd = self.pwd
1624 def _open_to_write(self, zinfo, force_zip64=False):
1625 if force_zip64 and not self._allowZip64:
1630 if self._writing:
1643 if not self._seekable:
1651 if not self._allowZip64 and zip64:
1654 if self._seekable:
1655 self.fp.seek(self.start_dir)
1656 zinfo.header_offset = self.fp.tell()
1658 self._writecheck(zinfo)
1659 self._didModify = True
1661 self.fp.write(zinfo.FileHeader(zip64))
1663 self._writing = True
1664 return _ZipWriteFile(self, zinfo, zip64)
1666 def extract(self, member, path=None, pwd=None):
1677 return self._extract_member(member, path, pwd)
1679 def extractall(self, path=None, members=None, pwd=None):
1686 members = self.namelist()
1694 self._extract_member(zipinfo, path, pwd)
1711 def _extract_member(self, member, targetpath, pwd):
1716 member = self.getinfo(member)
1732 arcname = self._sanitize_windows_name(arcname, os.path.sep)
1747 with self.open(member, pwd=pwd) as source, \
1753 def _writecheck(self, zinfo):
1755 if zinfo.filename in self.NameToInfo:
1758 if self.mode not in ('w', 'x', 'a'):
1760 if not self.fp:
1764 if not self._allowZip64:
1766 if len(self.filelist) >= ZIP_FILECOUNT_LIMIT:
1776 def write(self, filename, arcname=None,
1780 if not self.fp:
1783 if self._writing:
1789 strict_timestamps=self._strict_timestamps)
1794 self.mkdir(zinfo)
1799 zinfo.compress_type = self.compression
1804 zinfo._compresslevel = self.compresslevel
1806 with open(filename, "rb") as src, self.open(zinfo, 'w') as dest:
1809 def writestr(self, zinfo_or_arcname, data,
1821 zinfo.compress_type = self.compression
1822 zinfo._compresslevel = self.compresslevel
1831 if not self.fp:
1834 if self._writing:
1846 with self._lock:
1847 with self.open(zinfo, mode='w') as dest:
1850 def mkdir(self, zinfo_or_directory_name, mode=511):
1869 with self._lock:
1870 if self._seekable:
1871 self.fp.seek(self.start_dir)
1872 zinfo.header_offset = self.fp.tell() # Start of header bytes
1877 self._writecheck(zinfo)
1878 self._didModify = True
1880 self.filelist.append(zinfo)
1881 self.NameToInfo[zinfo.filename] = zinfo
1882 self.fp.write(zinfo.FileHeader(False))
1883 self.start_dir = self.fp.tell()
1885 def __del__(self):
1887 self.close()
1889 def close(self):
1892 if self.fp is None:
1895 if self._writing:
1901 if self.mode in ('w', 'x', 'a') and self._didModify: # write ending records
1902 with self._lock:
1903 if self._seekable:
1904 self.fp.seek(self.start_dir)
1905 self._write_end_record()
1907 fp = self.fp
1908 self.fp = None
1909 self._fpclose(fp)
1911 def _write_end_record(self):
1912 for zinfo in self.filelist: # write central directory
1960 self.fp.write(centdir)
1961 self.fp.write(filename)
1962 self.fp.write(extra_data)
1963 self.fp.write(zinfo.comment)
1965 pos2 = self.fp.tell()
1967 centDirCount = len(self.filelist)
1968 centDirSize = pos2 - self.start_dir
1969 centDirOffset = self.start_dir
1979 if not self._allowZip64:
1986 self.fp.write(zip64endrec)
1991 self.fp.write(zip64locrec)
1998 centDirSize, centDirOffset, len(self._comment))
1999 self.fp.write(endrec)
2000 self.fp.write(self._comment)
2001 if self.mode == "a":
2002 self.fp.truncate()
2003 self.fp.flush()
2005 def _fpclose(self, fp):
2006 assert self._fileRefCnt > 0
2007 self._fileRefCnt -= 1
2008 if not self._fileRefCnt and not self._filePassed:
2015 def __init__(self, file, mode="r", compression=ZIP_STORED,
2017 ZipFile.__init__(self, file, mode=mode, compression=compression,
2019 self._optimize = optimize
2021 def writepy(self, pathname, basename="", filterfunc=None):
2037 if self.debug:
2050 if self.debug:
2052 fname, arcname = self._get_codename(initname[0:-3], basename)
2053 if self.debug:
2055 self.write(fname, arcname)
2065 self.writepy(path, basename,
2069 if self.debug:
2072 fname, arcname = self._get_codename(path[0:-3],
2074 if self.debug:
2076 self.write(fname, arcname)
2079 if self.debug:
2086 if self.debug:
2089 fname, arcname = self._get_codename(path[0:-3],
2091 if self.debug:
2093 self.write(fname, arcname)
2098 fname, arcname = self._get_codename(pathname[0:-3], basename)
2099 if self.debug:
2101 self.write(fname, arcname)
2103 def _get_codename(self, pathname, basename):
2112 if self.debug:
2126 if self._optimize == -1:
2164 if self._optimize == 0:
2169 if self._optimize == 1:
2171 elif self._optimize == 2:
2174 msg = "invalid value for 'optimize': {!r}".format(self._optimize)
2178 if not _compile(file_py, optimize=self._optimize):
2244 def namelist(self):
2245 return list(map(self._sanitize, super().namelist()))
2309 def namelist(self):
2310 names = super(CompleteDirs, self).namelist()
2311 return names + list(self._implied_dirs(names))
2313 def _name_set(self):
2314 return set(self.namelist())
2316 def resolve_dir(self, name):
2321 names = self._name_set()
2326 def getinfo(self, name):
2333 if not name.endswith('/') or name not in self._name_set():
2363 def namelist(self):
2365 return self.__names
2366 self.__names = super(FastLookup, self).namelist()
2367 return self.__names
2369 def _name_set(self):
2371 return self.__lookup
2372 self.__lookup = super(FastLookup, self)._name_set()
2373 return self.__lookup
2459 __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"
2461 def __init__(self, root, at=""):
2471 self.root = FastLookup.make(root)
2472 self.at = at
2474 def open(self, mode='r', *args, pwd=None, **kwargs):
2480 if self.is_dir():
2481 raise IsADirectoryError(self)
2483 if not self.exists() and zip_mode == 'r':
2484 raise FileNotFoundError(self)
2485 stream = self.root.open(self.at, zip_mode, pwd=pwd)
2495 def name(self):
2496 return pathlib.Path(self.at).name or self.filename.name
2499 def suffix(self):
2500 return pathlib.Path(self.at).suffix or self.filename.suffix
2503 def suffixes(self):
2504 return pathlib.Path(self.at).suffixes or self.filename.suffixes
2507 def stem(self):
2508 return pathlib.Path(self.at).stem or self.filename.stem
2511 def filename(self):
2512 return pathlib.Path(self.root.filename).joinpath(self.at)
2514 def read_text(self, *args, **kwargs):
2516 with self.open('r', encoding, *args, **kwargs) as strm:
2519 def read_bytes(self):
2520 with self.open('rb') as strm:
2523 def _is_child(self, path):
2524 return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")
2526 def _next(self, at):
2527 return self.__class__(self.root, at)
2529 def is_dir(self):
2530 return not self.at or self.at.endswith("/")
2532 def is_file(self):
2533 return self.exists() and not self.is_dir()
2535 def exists(self):
2536 return self.at in self.root._name_set()
2538 def iterdir(self):
2539 if not self.is_dir():
2541 subs = map(self._next, self.root.namelist())
2542 return filter(self._is_child, subs)
2544 def __str__(self):
2545 return posixpath.join(self.root.filename, self.at)
2547 def __repr__(self):
2548 return self.__repr.format(self=self)
2550 def joinpath(self, *other):
2551 next = posixpath.join(self.at, *other)
2552 return self._next(self.root.resolve_dir(next))
2557 def parent(self):
2558 if not self.at:
2559 return self.filename.parent
2560 parent_at = posixpath.dirname(self.at.rstrip('/'))
2563 return self._next(parent_at)