Lines Matching refs:self
314 def __init__(self, name, mode):
321 self.fd = os.open(name, mode, 0o666)
323 def close(self):
324 os.close(self.fd)
326 def read(self, size):
327 return os.read(self.fd, size)
329 def write(self, s):
330 os.write(self.fd, s)
343 def __init__(self, name, mode, comptype, fileobj, bufsize):
346 self._extfileobj = True
349 self._extfileobj = False
357 self.name = name or ""
358 self.mode = mode
359 self.comptype = comptype
360 self.fileobj = fileobj
361 self.bufsize = bufsize
362 self.buf = b""
363 self.pos = 0
364 self.closed = False
372 self.zlib = zlib
373 self.crc = zlib.crc32(b"")
375 self._init_read_gz()
376 self.exception = zlib.error
378 self._init_write_gz()
386 self.dbuf = b""
387 self.cmp = bz2.BZ2Decompressor()
388 self.exception = OSError
390 self.cmp = bz2.BZ2Compressor()
398 self.dbuf = b""
399 self.cmp = lzma.LZMADecompressor()
400 self.exception = lzma.LZMAError
402 self.cmp = lzma.LZMACompressor()
408 if not self._extfileobj:
409 self.fileobj.close()
410 self.closed = True
413 def __del__(self):
414 if hasattr(self, "closed") and not self.closed:
415 self.close()
417 def _init_write_gz(self):
420 self.cmp = self.zlib.compressobj(9, self.zlib.DEFLATED,
421 -self.zlib.MAX_WBITS,
422 self.zlib.DEF_MEM_LEVEL,
425 self.__write(b"\037\213\010\010" + timestamp + b"\002\377")
426 if self.name.endswith(".gz"):
427 self.name = self.name[:-3]
429 self.name = os.path.basename(self.name)
431 self.__write(self.name.encode("iso-8859-1", "replace") + NUL)
433 def write(self, s):
436 if self.comptype == "gz":
437 self.crc = self.zlib.crc32(s, self.crc)
438 self.pos += len(s)
439 if self.comptype != "tar":
440 s = self.cmp.compress(s)
441 self.__write(s)
443 def __write(self, s):
447 self.buf += s
448 while len(self.buf) > self.bufsize:
449 self.fileobj.write(self.buf[:self.bufsize])
450 self.buf = self.buf[self.bufsize:]
452 def close(self):
456 if self.closed:
459 self.closed = True
461 if self.mode == "w" and self.comptype != "tar":
462 self.buf += self.cmp.flush()
464 if self.mode == "w" and self.buf:
465 self.fileobj.write(self.buf)
466 self.buf = b""
467 if self.comptype == "gz":
468 self.fileobj.write(struct.pack("<L", self.crc))
469 self.fileobj.write(struct.pack("<L", self.pos & 0xffffFFFF))
471 if not self._extfileobj:
472 self.fileobj.close()
474 def _init_read_gz(self):
477 self.cmp = self.zlib.decompressobj(-self.zlib.MAX_WBITS)
478 self.dbuf = b""
481 if self.__read(2) != b"\037\213":
483 if self.__read(1) != b"\010":
486 flag = ord(self.__read(1))
487 self.__read(6)
490 xlen = ord(self.__read(1)) + 256 * ord(self.__read(1))
491 self.read(xlen)
494 s = self.__read(1)
499 s = self.__read(1)
503 self.__read(2)
505 def tell(self):
508 return self.pos
510 def seek(self, pos=0):
514 if pos - self.pos >= 0:
515 blocks, remainder = divmod(pos - self.pos, self.bufsize)
517 self.read(self.bufsize)
518 self.read(remainder)
521 return self.pos
523 def read(self, size):
526 buf = self._read(size)
527 self.pos += len(buf)
530 def _read(self, size):
533 if self.comptype == "tar":
534 return self.__read(size)
536 c = len(self.dbuf)
537 t = [self.dbuf]
540 if self.buf:
541 buf = self.buf
542 self.buf = b""
544 buf = self.fileobj.read(self.bufsize)
548 buf = self.cmp.decompress(buf)
549 except self.exception as e:
554 self.dbuf = t[size:]
557 def __read(self, size):
561 c = len(self.buf)
562 t = [self.buf]
564 buf = self.fileobj.read(self.bufsize)
570 self.buf = t[size:]
579 def __init__(self, fileobj):
580 self.fileobj = fileobj
581 self.buf = self.fileobj.read(BLOCKSIZE)
583 def read(self, size):
584 self.read = self.fileobj.read
585 return self.buf
587 def getcomptype(self):
588 if self.buf.startswith(b"\x1f\x8b\x08"):
590 elif self.buf[0:3] == b"BZh" and self.buf[4:10] == b"1AY&SY":
592 elif self.buf.startswith((b"\x5d\x00\x00\x80", b"\xfd7zXZ")):
597 def close(self):
598 self.fileobj.close()
610 def __init__(self, fileobj, offset, size, blockinfo=None):
611 self.fileobj = fileobj
612 self.offset = offset
613 self.size = size
614 self.position = 0
615 self.name = getattr(fileobj, "name", None)
616 self.closed = False
622 self.map_index = 0
623 self.map = []
625 realpos = self.offset
628 self.map.append((False, lastpos, offset, None))
629 self.map.append((True, offset, offset + size, realpos))
632 if lastpos < self.size:
633 self.map.append((False, lastpos, self.size, None))
635 def flush(self):
638 def readable(self):
641 def writable(self):
644 def seekable(self):
645 return self.fileobj.seekable()
647 def tell(self):
650 return self.position
652 def seek(self, position, whence=io.SEEK_SET):
656 self.position = min(max(position, 0), self.size)
659 self.position = max(self.position + position, 0)
661 self.position = min(self.position + position, self.size)
663 self.position = max(min(self.size + position, self.size), 0)
666 return self.position
668 def read(self, size=None):
672 size = self.size - self.position
674 size = min(size, self.size - self.position)
679 data, start, stop, offset = self.map[self.map_index]
680 if start <= self.position < stop:
683 self.map_index += 1
684 if self.map_index == len(self.map):
685 self.map_index = 0
686 length = min(size, stop - self.position)
688 self.fileobj.seek(offset + (self.position - start))
689 b = self.fileobj.read(length)
696 self.position += length
699 def readinto(self, b):
700 buf = self.read(len(b))
704 def close(self):
705 self.closed = True
710 def __init__(self, tarfile, tarinfo):
725 def __init__(self, tarinfo):
726 self.tarinfo = tarinfo
730 def __init__(self, tarinfo, path):
731 self.tarinfo = tarinfo
732 self._path = path
737 def __init__(self, tarinfo):
738 self.tarinfo = tarinfo
742 def __init__(self, tarinfo):
743 self.tarinfo = tarinfo
747 def __init__(self, tarinfo, path):
748 self.tarinfo = tarinfo
749 self._path = path
875 def __init__(self, name=""):
879 self.name = name # member name
880 self.mode = 0o644 # file permissions
881 self.uid = 0 # user id
882 self.gid = 0 # group id
883 self.size = 0 # file size
884 self.mtime = 0 # modification time
885 self.chksum = 0 # header checksum
886 self.type = REGTYPE # member type
887 self.linkname = "" # link name
888 self.uname = "" # user name
889 self.gname = "" # group name
890 self.devmajor = 0 # device major number
891 self.devminor = 0 # device minor number
893 self.offset = 0 # the tar header starts here
894 self.offset_data = 0 # the file's data starts here
896 self.sparse = None # sparse member information
897 self.pax_headers = {} # pax header information
900 def path(self):
902 return self.name
905 def path(self, name):
906 self.name = name
909 def linkpath(self):
911 return self.linkname
914 def linkpath(self, linkname):
915 self.linkname = linkname
917 def __repr__(self):
918 return "<%s %r at %#x>" % (self.__class__.__name__,self.name,id(self))
920 def replace(self, *,
924 """Return a deep copy of self with the given attributes replaced.
927 result = copy.deepcopy(self)
929 result = copy.copy(self)
948 def get_info(self):
951 if self.mode is None:
954 mode = self.mode & 0o7777
956 "name": self.name,
958 "uid": self.uid,
959 "gid": self.gid,
960 "size": self.size,
961 "mtime": self.mtime,
962 "chksum": self.chksum,
963 "type": self.type,
964 "linkname": self.linkname,
965 "uname": self.uname,
966 "gname": self.gname,
967 "devmajor": self.devmajor,
968 "devminor": self.devminor
976 def tobuf(self, format=DEFAULT_FORMAT, encoding=ENCODING, errors="surrogateescape"):
979 info = self.get_info()
985 return self.create_ustar_header(info, encoding, errors)
987 return self.create_gnu_header(info, encoding, errors)
989 return self.create_pax_header(info, encoding)
993 def create_ustar_header(self, info, encoding, errors):
1002 info["prefix"], info["name"] = self._posix_split_name(info["name"], encoding, errors)
1004 return self._create_header(info, USTAR_FORMAT, encoding, errors)
1006 def create_gnu_header(self, info, encoding, errors):
1013 buf += self._create_gnu_long_header(info["linkname"], GNUTYPE_LONGLINK, encoding, errors)
1016 buf += self._create_gnu_long_header(info["name"], GNUTYPE_LONGNAME, encoding, errors)
1018 return buf + self._create_header(info, GNU_FORMAT, encoding, errors)
1020 def create_pax_header(self, info, encoding):
1026 pax_headers = self.pax_headers.copy()
1072 buf = self._create_pax_generic_header(pax_headers, XHDTYPE, encoding)
1076 return buf + self._create_header(info, USTAR_FORMAT, "ascii", "replace")
1084 def _posix_split_name(self, name, encoding, errors):
1299 # 1. Set self.offset_data to the position where the data blocks begin,
1303 # 3. Return self or another valid TarInfo object.
1304 def _proc_member(self, tarfile):
1308 if self.type in (GNUTYPE_LONGNAME, GNUTYPE_LONGLINK):
1309 return self._proc_gnulong(tarfile)
1310 elif self.type == GNUTYPE_SPARSE:
1311 return self._proc_sparse(tarfile)
1312 elif self.type in (XHDTYPE, XGLTYPE, SOLARIS_XHDTYPE):
1313 return self._proc_pax(tarfile)
1315 return self._proc_builtin(tarfile)
1317 def _proc_builtin(self, tarfile):
1321 self.offset_data = tarfile.fileobj.tell()
1322 offset = self.offset_data
1323 if self.isreg() or self.type not in SUPPORTED_TYPES:
1325 offset += self._block(self.size)
1330 self._apply_pax_info(tarfile.pax_headers, tarfile.encoding, tarfile.errors)
1334 if self.isdir():
1335 self.name = self.name.rstrip("/")
1337 return self
1339 def _proc_gnulong(self, tarfile):
1343 buf = tarfile.fileobj.read(self._block(self.size))
1347 next = self.fromtarfile(tarfile)
1353 next.offset = self.offset
1354 if self.type == GNUTYPE_LONGNAME:
1356 elif self.type == GNUTYPE_LONGLINK:
1366 def _proc_sparse(self, tarfile):
1370 structs, isextended, origsize = self._sparse_structs
1371 del self._sparse_structs
1387 self.sparse = structs
1389 self.offset_data = tarfile.fileobj.tell()
1390 tarfile.offset = self.offset_data + self._block(self.size)
1391 self.size = origsize
1392 return self
1394 def _proc_pax(self, tarfile):
1399 buf = tarfile.fileobj.read(self._block(self.size))
1404 if self.type == XGLTYPE:
1469 keyword = self._decode_pax_field(raw_keyword, "utf-8", "utf-8",
1472 value = self._decode_pax_field(raw_value, encoding, tarfile.encoding,
1475 value = self._decode_pax_field(raw_value, "utf-8", "utf-8",
1482 next = self.fromtarfile(tarfile)
1489 self._proc_gnusparse_01(next, pax_headers)
1493 self._proc_gnusparse_00(next, raw_headers)
1497 self._proc_gnusparse_10(next, pax_headers, tarfile)
1499 if self.type in (XHDTYPE, SOLARIS_XHDTYPE):
1502 next.offset = self.offset
1515 def _proc_gnusparse_00(self, next, raw_headers):
1535 def _proc_gnusparse_01(self, next, pax_headers):
1541 def _proc_gnusparse_10(self, next, pax_headers, tarfile):
1557 def _apply_pax_info(self, pax_headers, encoding, errors):
1563 setattr(self, "path", value)
1565 setattr(self, "size", int(value))
1567 setattr(self, "size", int(value))
1576 setattr(self, keyword, value)
1578 self.pax_headers = pax_headers.copy()
1580 def _decode_pax_field(self, value, encoding, fallback_encoding, fallback_errors):
1588 def _block(self, count):
1597 def isreg(self):
1599 return self.type in REGULAR_TYPES
1601 def isfile(self):
1603 return self.isreg()
1605 def isdir(self):
1607 return self.type == DIRTYPE
1609 def issym(self):
1611 return self.type == SYMTYPE
1613 def islnk(self):
1615 return self.type == LNKTYPE
1617 def ischr(self):
1619 return self.type == CHRTYPE
1621 def isblk(self):
1623 return self.type == BLKTYPE
1625 def isfifo(self):
1627 return self.type == FIFOTYPE
1629 def issparse(self):
1630 return self.sparse is not None
1632 def isdev(self):
1634 return self.type in (CHRTYPE, BLKTYPE, FIFOTYPE)
1665 def __init__(self, name=None, mode="r", fileobj=None, format=None,
1680 self.mode = mode
1681 self._mode = modes[mode]
1684 if self.mode == "a" and not os.path.exists(name):
1686 self.mode = "w"
1687 self._mode = "wb"
1688 fileobj = bltn_open(name, self._mode)
1689 self._extfileobj = False
1695 self._mode = fileobj.mode
1696 self._extfileobj = True
1697 self.name = os.path.abspath(name) if name else None
1698 self.fileobj = fileobj
1702 self.format = format
1704 self.tarinfo = tarinfo
1706 self.dereference = dereference
1708 self.ignore_zeros = ignore_zeros
1710 self.encoding = encoding
1711 self.errors = errors
1713 if pax_headers is not None and self.format == PAX_FORMAT:
1714 self.pax_headers = pax_headers
1716 self.pax_headers = {}
1719 self.debug = debug
1721 self.errorlevel = errorlevel
1724 self.copybufsize = copybufsize
1725 self.closed = False
1726 self.members = [] # list of members as TarInfo objects
1727 self._loaded = False # flag if all members have been read
1728 self.offset = self.fileobj.tell()
1730 self.inodes = {} # dictionary caching the inodes of
1734 if self.mode == "r":
1735 self.firstmember = None
1736 self.firstmember = self.next()
1738 if self.mode == "a":
1742 self.fileobj.seek(self.offset)
1744 tarinfo = self.tarinfo.fromtarfile(self)
1745 self.members.append(tarinfo)
1747 self.fileobj.seek(self.offset)
1752 if self.mode in ("a", "w", "x"):
1753 self._loaded = True
1755 if self.pax_headers:
1756 buf = self.tarinfo.create_pax_global_header(self.pax_headers.copy())
1757 self.fileobj.write(buf)
1758 self.offset += len(buf)
1760 if not self._extfileobj:
1761 self.fileobj.close()
1762 self.closed = True
1978 def close(self):
1982 if self.closed:
1985 self.closed = True
1987 if self.mode in ("a", "w", "x"):
1988 self.fileobj.write(NUL * (BLOCKSIZE * 2))
1989 self.offset += (BLOCKSIZE * 2)
1992 blocks, remainder = divmod(self.offset, RECORDSIZE)
1994 self.fileobj.write(NUL * (RECORDSIZE - remainder))
1996 if not self._extfileobj:
1997 self.fileobj.close()
1999 def getmember(self, name):
2005 tarinfo = self._getmember(name.rstrip('/'))
2010 def getmembers(self):
2014 self._check()
2015 if not self._loaded: # if we want to obtain a list of
2016 self._load() # all members, we first have to
2018 return self.members
2020 def getnames(self):
2024 return [tarinfo.name for tarinfo in self.getmembers()]
2026 def gettarinfo(self, name=None, arcname=None, fileobj=None):
2035 self._check("awx")
2053 tarinfo = self.tarinfo()
2054 tarinfo.tarfile = self # Not needed
2058 if not self.dereference:
2069 if not self.dereference and statres.st_nlink > 1 and \
2070 inode in self.inodes and arcname != self.inodes[inode]:
2074 linkname = self.inodes[inode]
2080 self.inodes[inode] = arcname
2125 def list(self, verbose=True, *, members=None):
2131 self._check()
2134 members = self
2163 def add(self, name, arcname=None, recursive=True, *, filter=None):
2173 self._check("awx")
2179 if self.name is not None and os.path.abspath(name) == self.name:
2180 self._dbg(2, "tarfile: Skipped %r" % name)
2183 self._dbg(1, name)
2186 tarinfo = self.gettarinfo(name, arcname)
2189 self._dbg(1, "tarfile: Unsupported type %r" % name)
2196 self._dbg(2, "tarfile: Excluded %r" % name)
2202 self.addfile(tarinfo, f)
2205 self.addfile(tarinfo)
2208 self.add(os.path.join(name, f), os.path.join(arcname, f),
2212 self.addfile(tarinfo)
2214 def addfile(self, tarinfo, fileobj=None):
2220 self._check("awx")
2224 buf = tarinfo.tobuf(self.format, self.encoding, self.errors)
2225 self.fileobj.write(buf)
2226 self.offset += len(buf)
2227 bufsize=self.copybufsize
2230 copyfileobj(fileobj, self.fileobj, tarinfo.size, bufsize=bufsize)
2233 self.fileobj.write(NUL * (BLOCKSIZE - remainder))
2235 self.offset += blocks * BLOCKSIZE
2237 self.members.append(tarinfo)
2239 def _get_filter_function(self, filter):
2241 filter = self.extraction_filter
2257 def extractall(self, path=".", members=None, *, numeric_owner=False,
2273 filter_function = self._get_filter_function(filter)
2275 members = self
2278 tarinfo = self._get_extract_tarinfo(member, filter_function, path)
2286 self._extract_one(tarinfo, path, set_attrs=not tarinfo.isdir(),
2296 self.chown(tarinfo, dirpath, numeric_owner=numeric_owner)
2297 self.utime(tarinfo, dirpath)
2298 self.chmod(tarinfo, dirpath)
2300 self._handle_nonfatal_error(e)
2302 def extract(self, member, path="", set_attrs=True, *, numeric_owner=False,
2316 filter_function = self._get_filter_function(filter)
2317 tarinfo = self._get_extract_tarinfo(member, filter_function, path)
2319 self._extract_one(tarinfo, path, set_attrs, numeric_owner)
2321 def _get_extract_tarinfo(self, member, filter_function, path):
2324 tarinfo = self.getmember(member)
2332 self._handle_fatal_error(e)
2334 self._handle_nonfatal_error(e)
2336 self._dbg(2, "tarfile: Excluded %r" % unfiltered.name)
2344 def _extract_one(self, tarinfo, path, set_attrs, numeric_owner):
2346 self._check("r")
2349 self._extract_member(tarinfo, os.path.join(path, tarinfo.name),
2353 self._handle_fatal_error(e)
2355 self._handle_nonfatal_error(e)
2357 def _handle_nonfatal_error(self, e):
2359 if self.errorlevel > 1:
2362 self._dbg(1, "tarfile: %s" % e)
2364 def _handle_fatal_error(self, e):
2365 """Handle "fatal" error according to self.errorlevel"""
2366 if self.errorlevel > 0:
2370 self._dbg(1, "tarfile: %s" % e.strerror)
2372 self._dbg(1, "tarfile: %s %r" % (e.strerror, e.filename))
2374 self._dbg(1, "tarfile: %s %s" % (type(e).__name__, e))
2376 def extractfile(self, member):
2383 self._check("r")
2386 tarinfo = self.getmember(member)
2392 return self.fileobject(self, tarinfo)
2395 if isinstance(self.fileobj, _Stream):
2402 return self.extractfile(self._find_link_target(tarinfo))
2408 def _extract_member(self, tarinfo, targetpath, set_attrs=True,
2427 self._dbg(1, "%s -> %s" % (tarinfo.name, tarinfo.linkname))
2429 self._dbg(1, tarinfo.name)
2432 self.makefile(tarinfo, targetpath)
2434 self.makedir(tarinfo, targetpath)
2436 self.makefifo(tarinfo, targetpath)
2438 self.makedev(tarinfo, targetpath)
2440 self.makelink(tarinfo, targetpath)
2442 self.makeunknown(tarinfo, targetpath)
2444 self.makefile(tarinfo, targetpath)
2447 self.chown(tarinfo, targetpath, numeric_owner)
2449 self.chmod(tarinfo, targetpath)
2450 self.utime(tarinfo, targetpath)
2457 def makedir(self, tarinfo, targetpath):
2471 def makefile(self, tarinfo, targetpath):
2474 source = self.fileobj
2476 bufsize = self.copybufsize
2487 def makeunknown(self, tarinfo, targetpath):
2491 self.makefile(tarinfo, targetpath)
2492 self._dbg(1, "tarfile: Unknown file type %r, " \
2495 def makefifo(self, tarinfo, targetpath):
2503 def makedev(self, tarinfo, targetpath):
2521 def makelink(self, tarinfo, targetpath):
2537 self._extract_member(self._find_link_target(tarinfo),
2541 self._extract_member(self._find_link_target(tarinfo),
2546 def chown(self, tarinfo, targetpath, numeric_owner):
2579 def chmod(self, tarinfo, targetpath):
2589 def utime(self, tarinfo, targetpath):
2603 def next(self):
2608 self._check("ra")
2609 if self.firstmember is not None:
2610 m = self.firstmember
2611 self.firstmember = None
2615 if self.offset != self.fileobj.tell():
2616 if self.offset == 0:
2618 self.fileobj.seek(self.offset - 1)
2619 if not self.fileobj.read(1):
2626 tarinfo = self.tarinfo.fromtarfile(self)
2628 if self.ignore_zeros:
2629 self._dbg(2, "0x%X: %s" % (self.offset, e))
2630 self.offset += BLOCKSIZE
2633 if self.ignore_zeros:
2634 self._dbg(2, "0x%X: %s" % (self.offset, e))
2635 self.offset += BLOCKSIZE
2637 elif self.offset == 0:
2640 if self.offset == 0:
2643 if self.offset == 0:
2659 self.members.append(tarinfo)
2661 self._loaded = True
2668 def _getmember(self, name, tarinfo=None, normalize=False):
2673 members = self.getmembers()
2708 def _load(self):
2713 tarinfo = self.next()
2716 self._loaded = True
2718 def _check(self, mode=None):
2722 if self.closed:
2723 raise OSError("%s is closed" % self.__class__.__name__)
2724 if mode is not None and self.mode not in mode:
2725 raise OSError("bad operation for mode %r" % self.mode)
2727 def _find_link_target(self, tarinfo):
2741 member = self._getmember(linkname, tarinfo=limit, normalize=True)
2746 def __iter__(self):
2749 if self._loaded:
2750 yield from self.members
2759 if self.firstmember is not None:
2760 tarinfo = self.next()
2765 if index < len(self.members):
2766 tarinfo = self.members[index]
2767 elif not self._loaded:
2768 tarinfo = self.next()
2770 self._loaded = True
2777 def _dbg(self, level, msg):
2780 if level <= self.debug:
2783 def __enter__(self):
2784 self._check()
2785 return self
2787 def __exit__(self, type, value, traceback):
2789 self.close()
2793 if not self._extfileobj:
2794 self.fileobj.close()
2795 self.closed = True