0UT1S's

lib64/python3.6/

By Order of Mr.0UT1S

N/A

[DIR] __pycache__

N/A

N/A

[DIR] collections

N/A

[DIR] concurrent

N/A

[DIR] config-3.6m-x86_64-linux-gnu

N/A

N/A

N/A

N/A

[DIR] distutils

N/A

N/A

[DIR] encodings

N/A

[DIR] ensurepip

N/A

N/A

N/A

[DIR] importlib

N/A

N/A

[DIR] lib-dynload

N/A

N/A

N/A

[DIR] multiprocessing

N/A

[DIR] pydoc_data

N/A

[DIR] site-packages

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

N/A

4.73 KB

__phello__.foo.py

64 bytes

1.27 KB

_collections_abc.py

25.77 KB

_compat_pickle.py

8.54 KB

_compression.py

5.21 KB

_dummy_thread.py

5.00 KB

14.26 KB

_osx_support.py

18.69 KB

224.83 KB

86.03 KB

_sitebuiltins.py

3.04 KB

24.17 KB

_sysconfigdata_dm_linux_x86_64-linux-gnu.py

29.48 KB

_sysconfigdata_m_linux_x86_64-linux-gnu.py

29.66 KB

_threading_local.py

7.04 KB

5.57 KB

8.52 KB

31.69 KB

477 bytes

88.25 KB

11.88 KB

11.06 KB

19.69 KB

19.91 KB

23.00 KB

13.63 KB

2.53 KB

12.19 KB

5.25 KB

22.67 KB

36.35 KB

11.74 KB

5.30 KB

14.51 KB

10.37 KB

35.43 KB

5.85 KB

3.97 KB

11.84 KB

configparser.py

52.34 KB

12.85 KB

8.61 KB

6.84 KB

1.82 KB

15.80 KB

80.11 KB

320 bytes

82.40 KB

17.71 KB

101.94 KB

dummy_threading.py

2.75 KB

32.82 KB

9.60 KB

14.13 KB

3.09 KB

14.79 KB

23.08 KB

34.78 KB

30.61 KB

4.64 KB

7.31 KB

5.85 KB

21.03 KB

5.51 KB

19.86 KB

8.59 KB

22.39 KB

6.23 KB

52.05 KB

3.71 KB

10.42 KB

114.22 KB

3.43 KB

75.99 KB

2.17 KB

5.19 KB

75.49 KB

12.68 KB

5.83 KB

2.67 KB

76.78 KB

8.85 KB

20.55 KB

modulefinder.py

22.49 KB

5.55 KB

42.07 KB

22.55 KB

2.39 KB

10.00 KB

5.69 KB

10.61 KB

58.96 KB

36.65 KB

47.83 KB

59.88 KB

54.39 KB

89.62 KB

8.71 KB

20.82 KB

46.11 KB

31.53 KB

14.61 KB

15.40 KB

20.37 KB

21.51 KB

25.94 KB

4.65 KB

7.01 KB

13.24 KB

101.08 KB

8.57 KB

7.09 KB

26.80 KB

15.19 KB

5.21 KB

6.93 KB

11.68 KB

6.36 KB

1.99 KB

18.98 KB

8.32 KB

12.65 KB

39.87 KB

2.07 KB

20.77 KB

33.91 KB

43.18 KB

6.92 KB

26.80 KB

socketserver.py

26.38 KB

18.88 KB

sre_constants.py

6.66 KB

35.68 KB

43.47 KB

4.92 KB

20.19 KB

11.52 KB

12.61 KB

257 bytes

60.88 KB

17.67 KB

2.07 KB

7.11 KB

24.29 KB

11.14 KB

104.88 KB

22.59 KB

27.41 KB

19.10 KB

1003 bytes

48.96 KB

13.03 KB

3.00 KB

28.80 KB

28.06 KB

22.91 KB

16.27 KB

879 bytes

8.66 KB

78.39 KB

6.60 KB

23.46 KB

18.05 KB

17.29 KB

19.99 KB

21.26 KB

5.77 KB

6.99 KB

78.05 KB

"""Pseudo terminal utilities."""

# Bugs: No signal handling.  Doesn't set slave termios and window size.
#       Only tested on Linux.
# See:  W. Richard Stevens. 1992.  Advanced Programming in the
#       UNIX Environment.  Chapter 19.
# Author: Steen Lumholt -- with additions by Guido.

from select import select
import os
import tty

__all__ = ["openpty","fork","spawn"]

STDIN_FILENO = 0
STDOUT_FILENO = 1
STDERR_FILENO = 2

CHILD = 0

def openpty():
    """openpty() -> (master_fd, slave_fd)
    Open a pty master/slave pair, using os.openpty() if possible."""

try:
        return os.openpty()
    except (AttributeError, OSError):
        pass
    master_fd, slave_name = _open_terminal()
    slave_fd = slave_open(slave_name)
    return master_fd, slave_fd

def master_open():
    """master_open() -> (master_fd, slave_name)
    Open a pty master and return the fd, and the filename of the slave end.
    Deprecated, use openpty() instead."""

try:
        master_fd, slave_fd = os.openpty()
    except (AttributeError, OSError):
        pass
    else:
        slave_name = os.ttyname(slave_fd)
        os.close(slave_fd)
        return master_fd, slave_name

return _open_terminal()

def _open_terminal():
    """Open pty master and return (master_fd, tty_name)."""
    for x in 'pqrstuvwxyzPQRST':
        for y in '0123456789abcdef':
            pty_name = '/dev/pty' + x + y
            try:
                fd = os.open(pty_name, os.O_RDWR)
            except OSError:
                continue
            return (fd, '/dev/tty' + x + y)
    raise OSError('out of pty devices')

def slave_open(tty_name):
    """slave_open(tty_name) -> slave_fd
    Open the pty slave and acquire the controlling terminal, returning
    opened filedescriptor.
    Deprecated, use openpty() instead."""

result = os.open(tty_name, os.O_RDWR)
    try:
        from fcntl import ioctl, I_PUSH
    except ImportError:
        return result
    try:
        ioctl(result, I_PUSH, "ptem")
        ioctl(result, I_PUSH, "ldterm")
    except OSError:
        pass
    return result

def fork():
    """fork() -> (pid, master_fd)
    Fork and make the child a session leader with a controlling terminal."""

try:
        pid, fd = os.forkpty()
    except (AttributeError, OSError):
        pass
    else:
        if pid == CHILD:
            try:
                os.setsid()
            except OSError:
                # os.forkpty() already set us session leader
                pass
        return pid, fd

master_fd, slave_fd = openpty()
    pid = os.fork()
    if pid == CHILD:
        # Establish a new session.
        os.setsid()
        os.close(master_fd)

# Slave becomes stdin/stdout/stderr of child.
        os.dup2(slave_fd, STDIN_FILENO)
        os.dup2(slave_fd, STDOUT_FILENO)
        os.dup2(slave_fd, STDERR_FILENO)
        if (slave_fd > STDERR_FILENO):
            os.close (slave_fd)

# Explicitly open the tty to make it become a controlling tty.
        tmp_fd = os.open(os.ttyname(STDOUT_FILENO), os.O_RDWR)
        os.close(tmp_fd)
    else:
        os.close(slave_fd)

# Parent and child process.
    return pid, master_fd

def _writen(fd, data):
    """Write all the data to a descriptor."""
    while data:
        n = os.write(fd, data)
        data = data[n:]

def _read(fd):
    """Default read function."""
    return os.read(fd, 1024)

def _copy(master_fd, master_read=_read, stdin_read=_read):
    """Parent copy loop.
    Copies
            pty master -> standard output   (master_read)
            standard input -> pty master    (stdin_read)"""
    fds = [master_fd, STDIN_FILENO]
    while True:
        rfds, wfds, xfds = select(fds, [], [])
        if master_fd in rfds:
            data = master_read(master_fd)
            if not data:  # Reached EOF.
                fds.remove(master_fd)
            else:
                os.write(STDOUT_FILENO, data)
        if STDIN_FILENO in rfds:
            data = stdin_read(STDIN_FILENO)
            if not data:
                fds.remove(STDIN_FILENO)
            else:
                _writen(master_fd, data)

def spawn(argv, master_read=_read, stdin_read=_read):
    """Create a spawned process."""
    if type(argv) == type(''):
        argv = (argv,)
    pid, master_fd = fork()
    if pid == CHILD:
        os.execlp(argv[0], *argv)
    try:
        mode = tty.tcgetattr(STDIN_FILENO)
        tty.setraw(STDIN_FILENO)
        restore = 1
    except tty.error:    # This is the same as termios.error
        restore = 0
    try:
        _copy(master_fd, master_read, stdin_read)
    except OSError:
        if restore:
            tty.tcsetattr(STDIN_FILENO, tty.TCSAFLUSH, mode)

os.close(master_fd)
    return os.waitpid(pid, 0)[1]