File Manager

X7ROOT File Manager

Current Path: /usr/lib64/python3.8

ðŸ“ ..
ðŸ“„ LICENSE.txt(13.61 KB)
ðŸ“„ __future__.py(5.03 KB)
ðŸ“„ __phello__.foo.py(64 B)
ðŸ“ __pycache__
ðŸ“„ _bootlocale.py(1.76 KB)
ðŸ“„ _collections_abc.py(25.49 KB)
ðŸ“„ _compat_pickle.py(8.54 KB)
ðŸ“„ _compression.py(5.21 KB)
ðŸ“„ _dummy_thread.py(5.89 KB)
ðŸ“„ _markupbase.py(14.26 KB)
ðŸ“„ _osx_support.py(21.26 KB)
ðŸ“„ _py_abc.py(6.04 KB)
ðŸ“„ _pydecimal.py(223.31 KB)
ðŸ“„ _pyio.py(90.99 KB)
ðŸ“„ _sitebuiltins.py(3.04 KB)
ðŸ“„ _strptime.py(24.68 KB)
ðŸ“„ _sysconfigdata__linux_x86_64-linux-gnu.py(37.61 KB)
ðŸ“„ _sysconfigdata_d_linux_x86_64-linux-gnu.py(37.34 KB)
ðŸ“„ _threading_local.py(7.05 KB)
ðŸ“„ _weakrefset.py(5.6 KB)
ðŸ“„ abc.py(4.38 KB)
ðŸ“„ aifc.py(32.04 KB)
ðŸ“„ antigravity.py(477 B)
ðŸ“„ argparse.py(93.76 KB)
ðŸ“„ ast.py(18.78 KB)
ðŸ“„ asynchat.py(11.06 KB)
ðŸ“ asyncio
ðŸ“„ asyncore.py(19.62 KB)
ðŸ“„ base64.py(19.9 KB)
ðŸ“„ bdb.py(31.3 KB)
ðŸ“„ binhex.py(13.63 KB)
ðŸ“„ bisect.py(2.16 KB)
ðŸ“„ bz2.py(12.26 KB)
ðŸ“„ cProfile.py(6.85 KB)
ðŸ“„ calendar.py(24.25 KB)
ðŸ“„ cgi.py(33.14 KB)
ðŸ“„ cgitb.py(11.81 KB)
ðŸ“„ chunk.py(5.31 KB)
ðŸ“„ cmd.py(14.51 KB)
ðŸ“„ code.py(10.37 KB)
ðŸ“„ codecs.py(35.81 KB)
ðŸ“„ codeop.py(6.18 KB)
ðŸ“ collections
ðŸ“„ colorsys.py(3.97 KB)
ðŸ“„ compileall.py(13.36 KB)
ðŸ“ concurrent
ðŸ“ config-3.8-x86_64-linux-gnu
ðŸ“„ configparser.py(53.1 KB)
ðŸ“„ contextlib.py(24.41 KB)
ðŸ“„ contextvars.py(129 B)
ðŸ“„ copy.py(8.46 KB)
ðŸ“„ copyreg.py(6.97 KB)
ðŸ“„ crypt.py(3.53 KB)
ðŸ“„ csv.py(15.77 KB)
ðŸ“ ctypes
ðŸ“ curses
ðŸ“„ dataclasses.py(48.8 KB)
ðŸ“„ datetime.py(86.22 KB)
ðŸ“ dbm
ðŸ“„ decimal.py(320 B)
ðŸ“„ difflib.py(82.09 KB)
ðŸ“„ dis.py(20.09 KB)
ðŸ“ distutils
ðŸ“„ doctest.py(102.09 KB)
ðŸ“„ dummy_threading.py(2.75 KB)
ðŸ“ email
ðŸ“ encodings
ðŸ“ ensurepip
ðŸ“„ enum.py(37.24 KB)
ðŸ“„ filecmp.py(9.6 KB)
ðŸ“„ fileinput.py(14.36 KB)
ðŸ“„ fnmatch.py(3.98 KB)
ðŸ“„ formatter.py(14.79 KB)
ðŸ“„ fractions.py(23.76 KB)
ðŸ“„ ftplib.py(34.31 KB)
ðŸ“„ functools.py(36.53 KB)
ðŸ“„ genericpath.py(4.86 KB)
ðŸ“„ getopt.py(7.31 KB)
ðŸ“„ getpass.py(5.85 KB)
ðŸ“„ gettext.py(26.5 KB)
ðŸ“„ glob.py(5.56 KB)
ðŸ“„ gzip.py(20.91 KB)
ðŸ“„ hashlib.py(8.14 KB)
ðŸ“„ heapq.py(22.34 KB)
ðŸ“„ hmac.py(7.67 KB)
ðŸ“ html
ðŸ“ http
ðŸ“„ imaplib.py(52.35 KB)
ðŸ“„ imghdr.py(3.72 KB)
ðŸ“„ imp.py(10.29 KB)
ðŸ“ importlib
ðŸ“„ inspect.py(115.77 KB)
ðŸ“„ io.py(3.46 KB)
ðŸ“„ ipaddress.py(69.96 KB)
ðŸ“ json
ðŸ“„ keyword.py(945 B)
ðŸ“ lib-dynload
ðŸ“ lib2to3
ðŸ“„ linecache.py(5.21 KB)
ðŸ“„ locale.py(76.36 KB)
ðŸ“ logging
ðŸ“„ lzma.py(12.68 KB)
ðŸ“„ mailbox.py(76.82 KB)
ðŸ“„ mailcap.py(8.85 KB)
ðŸ“„ mimetypes.py(21.16 KB)
ðŸ“„ modulefinder.py(23.86 KB)
ðŸ“ multiprocessing
ðŸ“„ netrc.py(5.44 KB)
ðŸ“„ nntplib.py(42.25 KB)
ðŸ“„ ntpath.py(27.08 KB)
ðŸ“„ nturl2path.py(2.82 KB)
ðŸ“„ numbers.py(10 KB)
ðŸ“„ opcode.py(5.67 KB)
ðŸ“„ operator.py(10.46 KB)
ðŸ“„ optparse.py(58.95 KB)
ðŸ“„ os.py(38.08 KB)
ðŸ“„ pathlib.py(51.38 KB)
ðŸ“„ pdb.py(61.27 KB)
ðŸ“„ pickle.py(62.96 KB)
ðŸ“„ pickletools.py(91.29 KB)
ðŸ“„ pipes.py(8.71 KB)
ðŸ“„ pkgutil.py(21 KB)
ðŸ“„ platform.py(39.48 KB)
ðŸ“„ plistlib.py(31.46 KB)
ðŸ“„ poplib.py(14.72 KB)
ðŸ“„ posixpath.py(15.26 KB)
ðŸ“„ pprint.py(20.98 KB)
ðŸ“„ profile.py(22.99 KB)
ðŸ“„ pstats.py(26.7 KB)
ðŸ“„ pty.py(4.69 KB)
ðŸ“„ py_compile.py(8.01 KB)
ðŸ“„ pyclbr.py(14.9 KB)
ðŸ“„ pydoc.py(104.2 KB)
ðŸ“ pydoc_data
ðŸ“„ queue.py(11.09 KB)
ðŸ“„ quopri.py(7.08 KB)
ðŸ“„ random.py(28.13 KB)
ðŸ“„ re.py(15.49 KB)
ðŸ“„ reprlib.py(5.14 KB)
ðŸ“„ rlcompleter.py(6.93 KB)
ðŸ“„ runpy.py(11.77 KB)
ðŸ“„ sched.py(6.29 KB)
ðŸ“„ secrets.py(1.99 KB)
ðŸ“„ selectors.py(18.13 KB)
ðŸ“„ shelve.py(8.33 KB)
ðŸ“„ shlex.py(13.01 KB)
ðŸ“„ shutil.py(50.55 KB)
ðŸ“„ signal.py(2.22 KB)
ðŸ“ site-packages
ðŸ“„ site.py(21.33 KB)
ðŸ“„ smtpd.py(33.9 KB)
ðŸ“„ smtplib.py(43.95 KB)
ðŸ“„ sndhdr.py(6.93 KB)
ðŸ“„ socket.py(34.42 KB)
ðŸ“„ socketserver.py(26.66 KB)
ðŸ“ sqlite3
ðŸ“„ sre_compile.py(26.07 KB)
ðŸ“„ sre_constants.py(6.99 KB)
ðŸ“„ sre_parse.py(39.29 KB)
ðŸ“„ ssl.py(49.57 KB)
ðŸ“„ stat.py(5.36 KB)
ðŸ“„ statistics.py(38.76 KB)
ðŸ“„ string.py(10.29 KB)
ðŸ“„ stringprep.py(12.61 KB)
ðŸ“„ struct.py(257 B)
ðŸ“„ subprocess.py(76.42 KB)
ðŸ“„ sunau.py(17.94 KB)
ðŸ“„ symbol.py(2.06 KB)
ðŸ“„ symtable.py(7.83 KB)
ðŸ“„ sysconfig.py(24.31 KB)
ðŸ“„ tabnanny.py(11.14 KB)
ðŸ“„ tarfile.py(103.98 KB)
ðŸ“„ telnetlib.py(22.71 KB)
ðŸ“„ tempfile.py(26.89 KB)
ðŸ“„ textwrap.py(18.95 KB)
ðŸ“„ this.py(1003 B)
ðŸ“„ threading.py(49.63 KB)
ðŸ“„ timeit.py(13.16 KB)
ðŸ“ tkinter
ðŸ“„ token.py(2.31 KB)
ðŸ“„ tokenize.py(25.24 KB)
ðŸ“„ trace.py(29.17 KB)
ðŸ“„ traceback.py(23.06 KB)
ðŸ“„ tracemalloc.py(16.68 KB)
ðŸ“„ tty.py(879 B)
ðŸ“„ turtle.py(140.35 KB)
ðŸ“ turtledemo
ðŸ“„ types.py(9.49 KB)
ðŸ“„ typing.py(67.35 KB)
ðŸ“ unittest
ðŸ“ urllib
ðŸ“„ uu.py(7.11 KB)
ðŸ“„ uuid.py(29.8 KB)
ðŸ“ venv
ðŸ“„ warnings.py(19.23 KB)
ðŸ“„ wave.py(17.8 KB)
ðŸ“„ weakref.py(20.89 KB)
ðŸ“„ webbrowser.py(23.52 KB)
ðŸ“ wsgiref
ðŸ“„ xdrlib.py(5.77 KB)
ðŸ“ xml
ðŸ“ xmlrpc
ðŸ“„ zipapp.py(7.36 KB)
ðŸ“„ zipfile.py(85.67 KB)
ðŸ“„ zipimport.py(30.04 KB)

Editing: binhex.py

"""Macintosh binhex compression/decompression.

easy interface:
binhex(inputfilename, outputfilename)
hexbin(inputfilename, outputfilename)
"""

#
# Jack Jansen, CWI, August 1995.
#
# The module is supposed to be as compatible as possible. Especially the
# easy interface should work "as expected" on any platform.
# XXXX Note: currently, textfiles appear in mac-form on all platforms.
# We seem to lack a simple character-translate in python.
# (we should probably use ISO-Latin-1 on all but the mac platform).
# XXXX The simple routines are too simple: they expect to hold the complete
# files in-core. Should be fixed.
# XXXX It would be nice to handle AppleDouble format on unix
# (for servers serving macs).
# XXXX I don't understand what happens when you get 0x90 times the same byte on
# input. The resulting code (xx 90 90) would appear to be interpreted as an
# escaped *value* of 0x90. All coders I've seen appear to ignore this nicety...
#
import io
import os
import struct
import binascii

__all__ = ["binhex","hexbin","Error"]

class Error(Exception):
    pass

# States (what have we written)
_DID_HEADER = 0
_DID_DATA = 1

# Various constants
REASONABLY_LARGE = 32768  # Minimal amount we pass the rle-coder
LINELEN = 64
RUNCHAR = b"\x90"

#
# This code is no longer byte-order dependent

class FInfo:
    def __init__(self):
        self.Type = '????'
        self.Creator = '????'
        self.Flags = 0

def getfileinfo(name):
    finfo = FInfo()
    with io.open(name, 'rb') as fp:
        # Quick check for textfile
        data = fp.read(512)
        if 0 not in data:
            finfo.Type = 'TEXT'
        fp.seek(0, 2)
        dsize = fp.tell()
    dir, file = os.path.split(name)
    file = file.replace(':', '-', 1)
    return file, finfo, dsize, 0

class openrsrc:
    def __init__(self, *args):
        pass

def read(self, *args):
        return b''

def write(self, *args):
        pass

def close(self):
        pass

class _Hqxcoderengine:
    """Write data to the coder in 3-byte chunks"""

def __init__(self, ofp):
        self.ofp = ofp
        self.data = b''
        self.hqxdata = b''
        self.linelen = LINELEN - 1

def write(self, data):
        self.data = self.data + data
        datalen = len(self.data)
        todo = (datalen // 3) * 3
        data = self.data[:todo]
        self.data = self.data[todo:]
        if not data:
            return
        self.hqxdata = self.hqxdata + binascii.b2a_hqx(data)
        self._flush(0)

def _flush(self, force):
        first = 0
        while first <= len(self.hqxdata) - self.linelen:
            last = first + self.linelen
            self.ofp.write(self.hqxdata[first:last] + b'\r')
            self.linelen = LINELEN
            first = last
        self.hqxdata = self.hqxdata[first:]
        if force:
            self.ofp.write(self.hqxdata + b':\r')

def close(self):
        if self.data:
            self.hqxdata = self.hqxdata + binascii.b2a_hqx(self.data)
        self._flush(1)
        self.ofp.close()
        del self.ofp

class _Rlecoderengine:
    """Write data to the RLE-coder in suitably large chunks"""

def __init__(self, ofp):
        self.ofp = ofp
        self.data = b''

def write(self, data):
        self.data = self.data + data
        if len(self.data) < REASONABLY_LARGE:
            return
        rledata = binascii.rlecode_hqx(self.data)
        self.ofp.write(rledata)
        self.data = b''

def close(self):
        if self.data:
            rledata = binascii.rlecode_hqx(self.data)
            self.ofp.write(rledata)
        self.ofp.close()
        del self.ofp

class BinHex:
    def __init__(self, name_finfo_dlen_rlen, ofp):
        name, finfo, dlen, rlen = name_finfo_dlen_rlen
        close_on_error = False
        if isinstance(ofp, str):
            ofname = ofp
            ofp = io.open(ofname, 'wb')
            close_on_error = True
        try:
            ofp.write(b'(This file must be converted with BinHex 4.0)\r\r:')
            hqxer = _Hqxcoderengine(ofp)
            self.ofp = _Rlecoderengine(hqxer)
            self.crc = 0
            if finfo is None:
                finfo = FInfo()
            self.dlen = dlen
            self.rlen = rlen
            self._writeinfo(name, finfo)
            self.state = _DID_HEADER
        except:
            if close_on_error:
                ofp.close()
            raise

def _writeinfo(self, name, finfo):
        nl = len(name)
        if nl > 63:
            raise Error('Filename too long')
        d = bytes([nl]) + name.encode("latin-1") + b'\0'
        tp, cr = finfo.Type, finfo.Creator
        if isinstance(tp, str):
            tp = tp.encode("latin-1")
        if isinstance(cr, str):
            cr = cr.encode("latin-1")
        d2 = tp + cr

# Force all structs to be packed with big-endian
        d3 = struct.pack('>h', finfo.Flags)
        d4 = struct.pack('>ii', self.dlen, self.rlen)
        info = d + d2 + d3 + d4
        self._write(info)
        self._writecrc()

def _write(self, data):
        self.crc = binascii.crc_hqx(data, self.crc)
        self.ofp.write(data)

def _writecrc(self):
        # XXXX Should this be here??
        # self.crc = binascii.crc_hqx('\0\0', self.crc)
        if self.crc < 0:
            fmt = '>h'
        else:
            fmt = '>H'
        self.ofp.write(struct.pack(fmt, self.crc))
        self.crc = 0

def write(self, data):
        if self.state != _DID_HEADER:
            raise Error('Writing data at the wrong time')
        self.dlen = self.dlen - len(data)
        self._write(data)

def close_data(self):
        if self.dlen != 0:
            raise Error('Incorrect data size, diff=%r' % (self.rlen,))
        self._writecrc()
        self.state = _DID_DATA

def write_rsrc(self, data):
        if self.state < _DID_DATA:
            self.close_data()
        if self.state != _DID_DATA:
            raise Error('Writing resource data at the wrong time')
        self.rlen = self.rlen - len(data)
        self._write(data)

def close(self):
        if self.state is None:
            return
        try:
            if self.state < _DID_DATA:
                self.close_data()
            if self.state != _DID_DATA:
                raise Error('Close at the wrong time')
            if self.rlen != 0:
                raise Error("Incorrect resource-datasize, diff=%r" % (self.rlen,))
            self._writecrc()
        finally:
            self.state = None
            ofp = self.ofp
            del self.ofp
            ofp.close()

def binhex(inp, out):
    """binhex(infilename, outfilename): create binhex-encoded copy of a file"""
    finfo = getfileinfo(inp)
    ofp = BinHex(finfo, out)

with io.open(inp, 'rb') as ifp:
        # XXXX Do textfile translation on non-mac systems
        while True:
            d = ifp.read(128000)
            if not d: break
            ofp.write(d)
        ofp.close_data()

ifp = openrsrc(inp, 'rb')
    while True:
        d = ifp.read(128000)
        if not d: break
        ofp.write_rsrc(d)
    ofp.close()
    ifp.close()

class _Hqxdecoderengine:
    """Read data via the decoder in 4-byte chunks"""

def __init__(self, ifp):
        self.ifp = ifp
        self.eof = 0

def read(self, totalwtd):
        """Read at least wtd bytes (or until EOF)"""
        decdata = b''
        wtd = totalwtd
        #
        # The loop here is convoluted, since we don't really now how
        # much to decode: there may be newlines in the incoming data.
        while wtd > 0:
            if self.eof: return decdata
            wtd = ((wtd + 2) // 3) * 4
            data = self.ifp.read(wtd)
            #
            # Next problem: there may not be a complete number of
            # bytes in what we pass to a2b. Solve by yet another
            # loop.
            #
            while True:
                try:
                    decdatacur, self.eof = binascii.a2b_hqx(data)
                    break
                except binascii.Incomplete:
                    pass
                newdata = self.ifp.read(1)
                if not newdata:
                    raise Error('Premature EOF on binhex file')
                data = data + newdata
            decdata = decdata + decdatacur
            wtd = totalwtd - len(decdata)
            if not decdata and not self.eof:
                raise Error('Premature EOF on binhex file')
        return decdata

def close(self):
        self.ifp.close()

class _Rledecoderengine:
    """Read data via the RLE-coder"""

def __init__(self, ifp):
        self.ifp = ifp
        self.pre_buffer = b''
        self.post_buffer = b''
        self.eof = 0

def read(self, wtd):
        if wtd > len(self.post_buffer):
            self._fill(wtd - len(self.post_buffer))
        rv = self.post_buffer[:wtd]
        self.post_buffer = self.post_buffer[wtd:]
        return rv

def _fill(self, wtd):
        self.pre_buffer = self.pre_buffer + self.ifp.read(wtd + 4)
        if self.ifp.eof:
            self.post_buffer = self.post_buffer + \
                binascii.rledecode_hqx(self.pre_buffer)
            self.pre_buffer = b''
            return

#
        # Obfuscated code ahead. We have to take care that we don't
        # end up with an orphaned RUNCHAR later on. So, we keep a couple
        # of bytes in the buffer, depending on what the end of
        # the buffer looks like:
        # '\220\0\220' - Keep 3 bytes: repeated \220 (escaped as \220\0)
        # '?\220' - Keep 2 bytes: repeated something-else
        # '\220\0' - Escaped \220: Keep 2 bytes.
        # '?\220?' - Complete repeat sequence: decode all
        # otherwise: keep 1 byte.
        #
        mark = len(self.pre_buffer)
        if self.pre_buffer[-3:] == RUNCHAR + b'\0' + RUNCHAR:
            mark = mark - 3
        elif self.pre_buffer[-1:] == RUNCHAR:
            mark = mark - 2
        elif self.pre_buffer[-2:] == RUNCHAR + b'\0':
            mark = mark - 2
        elif self.pre_buffer[-2:-1] == RUNCHAR:
            pass # Decode all
        else:
            mark = mark - 1

self.post_buffer = self.post_buffer + \
            binascii.rledecode_hqx(self.pre_buffer[:mark])
        self.pre_buffer = self.pre_buffer[mark:]

def close(self):
        self.ifp.close()

class HexBin:
    def __init__(self, ifp):
        if isinstance(ifp, str):
            ifp = io.open(ifp, 'rb')
        #
        # Find initial colon.
        #
        while True:
            ch = ifp.read(1)
            if not ch:
                raise Error("No binhex data found")
            # Cater for \r\n terminated lines (which show up as \n\r, hence
            # all lines start with \r)
            if ch == b'\r':
                continue
            if ch == b':':
                break

hqxifp = _Hqxdecoderengine(ifp)
        self.ifp = _Rledecoderengine(hqxifp)
        self.crc = 0
        self._readheader()

def _read(self, len):
        data = self.ifp.read(len)
        self.crc = binascii.crc_hqx(data, self.crc)
        return data

def _checkcrc(self):
        filecrc = struct.unpack('>h', self.ifp.read(2))[0] & 0xffff
        #self.crc = binascii.crc_hqx('\0\0', self.crc)
        # XXXX Is this needed??
        self.crc = self.crc & 0xffff
        if filecrc != self.crc:
            raise Error('CRC error, computed %x, read %x'
                        % (self.crc, filecrc))
        self.crc = 0

def _readheader(self):
        len = self._read(1)
        fname = self._read(ord(len))
        rest = self._read(1 + 4 + 4 + 2 + 4 + 4)
        self._checkcrc()

type = rest[1:5]
        creator = rest[5:9]
        flags = struct.unpack('>h', rest[9:11])[0]
        self.dlen = struct.unpack('>l', rest[11:15])[0]
        self.rlen = struct.unpack('>l', rest[15:19])[0]

self.FName = fname
        self.FInfo = FInfo()
        self.FInfo.Creator = creator
        self.FInfo.Type = type
        self.FInfo.Flags = flags

self.state = _DID_HEADER

def read(self, *n):
        if self.state != _DID_HEADER:
            raise Error('Read data at wrong time')
        if n:
            n = n[0]
            n = min(n, self.dlen)
        else:
            n = self.dlen
        rv = b''
        while len(rv) < n:
            rv = rv + self._read(n-len(rv))
        self.dlen = self.dlen - n
        return rv

def close_data(self):
        if self.state != _DID_HEADER:
            raise Error('close_data at wrong time')
        if self.dlen:
            dummy = self._read(self.dlen)
        self._checkcrc()
        self.state = _DID_DATA

def read_rsrc(self, *n):
        if self.state == _DID_HEADER:
            self.close_data()
        if self.state != _DID_DATA:
            raise Error('Read resource data at wrong time')
        if n:
            n = n[0]
            n = min(n, self.rlen)
        else:
            n = self.rlen
        self.rlen = self.rlen - n
        return self._read(n)

def close(self):
        if self.state is None:
            return
        try:
            if self.rlen:
                dummy = self.read_rsrc(self.rlen)
            self._checkcrc()
        finally:
            self.state = None
            self.ifp.close()

def hexbin(inp, out):
    """hexbin(infilename, outfilename) - Decode binhexed file"""
    ifp = HexBin(inp)
    finfo = ifp.FInfo
    if not out:
        out = ifp.FName

with io.open(out, 'wb') as ofp:
        # XXXX Do translation on non-mac systems
        while True:
            d = ifp.read(128000)
            if not d: break
            ofp.write(d)
    ifp.close_data()

d = ifp.read_rsrc(128000)
    if d:
        ofp = openrsrc(out, 'wb')
        ofp.write(d)
        while True:
            d = ifp.read_rsrc(128000)
            if not d: break
            ofp.write(d)
        ofp.close()

ifp.close()

X7ROOT File Manager

Editing: binhex.py

Upload File

Create Folder