FM / python3.4

/opt/alt/python34/lib64/python3.4

Name	Size	Mode	Actions
asyncio/	-	0755	rm
collections/	-	0755	rm
concurrent/	-	0755	rm
config-3.4m/	-	0755	rm
ctypes/	-	0755	rm
curses/	-	0755	rm
dbm/	-	0755	rm
distutils/	-	0755	rm
email/	-	0755	rm
encodings/	-	0755	rm
ensurepip/	-	0755	rm
html/	-	0755	rm
http/	-	0755	rm
idlelib/	-	0755	rm
importlib/	-	0755	rm
json/	-	0755	rm
lib-dynload/	-	0755	rm
lib2to3/	-	0755	rm
logging/	-	0755	rm
multiprocessing/	-	0755	rm
plat-linux/	-	0755	rm
pydoc_data/	-	0755	rm
site-packages/	-	0755	rm
sqlite3/	-	0755	rm
test/	-	0755	rm
unittest/	-	0755	rm
urllib/	-	0755	rm
venv/	-	0755	rm
wsgiref/	-	0755	rm
xml/	-	0755	rm
xmlrpc/	-	0755	rm
__pycache__/	-	0755	rm
abc.py	8624	0644	edit dl rm
aifc.py	31578	0644	edit dl rm
antigravity.py	475	0644	edit dl rm
argparse.py	90027	0644	edit dl rm
ast.py	12034	0644	edit dl rm
asynchat.py	11825	0644	edit dl rm
asyncore.py	20998	0644	edit dl rm
base64.py	20180	0755	edit dl rm
bdb.py	23354	0644	edit dl rm
binhex.py	13928	0644	edit dl rm
bisect.py	2595	0644	edit dl rm
bz2.py	18860	0644	edit dl rm
calendar.py	22941	0644	edit dl rm
cgi.py	35941	0755	edit dl rm
cgitb.py	12041	0644	edit dl rm
chunk.py	5425	0644	edit dl rm
cmd.py	14860	0644	edit dl rm
code.py	10037	0644	edit dl rm
codecs.py	35910	0644	edit dl rm
codeop.py	5994	0644	edit dl rm
colorsys.py	4064	0644	edit dl rm
compileall.py	9618	0644	edit dl rm
configparser.py	49698	0644	edit dl rm
contextlib.py	11639	0644	edit dl rm
copy.py	9005	0644	edit dl rm
copyreg.py	6833	0644	edit dl rm
cProfile.py	5324	0755	edit dl rm
crypt.py	1879	0644	edit dl rm
csv.py	16185	0644	edit dl rm
datetime.py	75804	0644	edit dl rm
decimal.py	228688	0644	edit dl rm
difflib.py	81684	0644	edit dl rm
dis.py	17160	0644	edit dl rm
doctest.py	104492	0644	edit dl rm
dummy_threading.py	2815	0644	edit dl rm
enum.py	21538	0644	edit dl rm
filecmp.py	9830	0644	edit dl rm
fileinput.py	14865	0644	edit dl rm
fnmatch.py	3163	0644	edit dl rm
formatter.py	15173	0644	edit dl rm
fractions.py	23203	0644	edit dl rm
ftplib.py	38532	0644	edit dl rm
functools.py	28511	0644	edit dl rm
genericpath.py	3882	0644	edit dl rm
getopt.py	7489	0644	edit dl rm
getpass.py	6069	0644	edit dl rm
gettext.py	20767	0644	edit dl rm
glob.py	3461	0644	edit dl rm
gzip.py	24314	0644	edit dl rm
hashlib.py	9850	0644	edit dl rm
heapq.py	17997	0644	edit dl rm
hmac.py	5063	0644	edit dl rm
imaplib.py	50267	0644	edit dl rm
imghdr.py	3528	0644	edit dl rm
imp.py	9984	0644	edit dl rm
inspect.py	104640	0644	edit dl rm
io.py	3396	0644	edit dl rm
ipaddress.py	71598	0644	edit dl rm
keyword.py	2222	0755	edit dl rm
linecache.py	3953	0644	edit dl rm
locale.py	74530	0644	edit dl rm
lzma.py	19371	0644	edit dl rm
macpath.py	5619	0644	edit dl rm
macurl2path.py	2732	0644	edit dl rm
mailbox.py	78382	0644	edit dl rm
mailcap.py	7437	0644	edit dl rm
mimetypes.py	20781	0644	edit dl rm
modulefinder.py	23421	0644	edit dl rm
netrc.py	5748	0644	edit dl rm
nntplib.py	43082	0644	edit dl rm
ntpath.py	20477	0644	edit dl rm
nturl2path.py	2444	0644	edit dl rm
numbers.py	10243	0644	edit dl rm
opcode.py	5442	0644	edit dl rm
operator.py	9195	0644	edit dl rm
optparse.py	60346	0644	edit dl rm
os.py	33882	0644	edit dl rm
pathlib.py	42467	0644	edit dl rm
pdb.py	60992	0755	edit dl rm
pickle.py	55989	0644	edit dl rm
pickletools.py	91762	0644	edit dl rm
pipes.py	8916	0644	edit dl rm
pkgutil.py	21215	0644	edit dl rm
platform.py	46761	0755	edit dl rm
plistlib.py	31791	0644	edit dl rm
poplib.py	14319	0644	edit dl rm
posixpath.py	13448	0644	edit dl rm
pprint.py	14919	0644	edit dl rm
profile.py	22032	0755	edit dl rm
pstats.py	26316	0644	edit dl rm
pty.py	4763	0644	edit dl rm
pyclbr.py	13520	0644	edit dl rm
pydoc.py	103011	0755	edit dl rm
py_compile.py	7103	0644	edit dl rm
queue.py	8835	0644	edit dl rm
quopri.py	7265	0755	edit dl rm
random.py	26084	0644	edit dl rm
re.py	15604	0644	edit dl rm
reprlib.py	5110	0644	edit dl rm
rlcompleter.py	6069	0644	edit dl rm
runpy.py	10816	0644	edit dl rm
sched.py	6354	0644	edit dl rm
selectors.py	17097	0644	edit dl rm
shelve.py	8528	0644	edit dl rm
shlex.py	11548	0644	edit dl rm
shutil.py	39902	0644	edit dl rm
site.py	21553	0644	edit dl rm
smtpd.py	29991	0755	edit dl rm
smtplib.py	38971	0755	edit dl rm
sndhdr.py	6256	0644	edit dl rm
socket.py	19067	0644	edit dl rm
socketserver.py	24372	0644	edit dl rm
sre_compile.py	19903	0644	edit dl rm
sre_constants.py	7267	0644	edit dl rm
sre_parse.py	31429	0644	edit dl rm
ssl.py	34747	0644	edit dl rm
stat.py	4400	0644	edit dl rm
statistics.py	19556	0644	edit dl rm
string.py	11445	0644	edit dl rm
stringprep.py	12917	0644	edit dl rm
struct.py	257	0644	edit dl rm
subprocess.py	64549	0644	edit dl rm
sunau.py	18095	0644	edit dl rm
symbol.py	2053	0755	edit dl rm
symtable.py	7404	0644	edit dl rm
sysconfig.py	24632	0644	edit dl rm
tabnanny.py	11410	0755	edit dl rm
tarfile.py	91557	0755	edit dl rm
telnetlib.py	23074	0644	edit dl rm
tempfile.py	22525	0644	edit dl rm
textwrap.py	19282	0644	edit dl rm
this.py	1003	0644	edit dl rm
threading.py	48802	0644	edit dl rm
timeit.py	11972	0755	edit dl rm
token.py	3034	0644	edit dl rm
tokenize.py	25596	0644	edit dl rm
trace.py	31487	0755	edit dl rm
traceback.py	11167	0644	edit dl rm
tracemalloc.py	15651	0644	edit dl rm
tty.py	879	0644	edit dl rm
types.py	5411	0644	edit dl rm
uu.py	6766	0755	edit dl rm
uuid.py	23724	0644	edit dl rm
warnings.py	14303	0644	edit dl rm
wave.py	17682	0644	edit dl rm
weakref.py	19384	0644	edit dl rm
webbrowser.py	21432	0755	edit dl rm
xdrlib.py	5913	0644	edit dl rm
zipfile.py	68547	0644	edit dl rm
_bootlocale.py	1301	0644	edit dl rm
_collections_abc.py	19898	0644	edit dl rm
_compat_pickle.py	8318	0644	edit dl rm
_dummy_thread.py	4872	0644	edit dl rm
_markupbase.py	14598	0644	edit dl rm
_osx_support.py	19101	0644	edit dl rm
_pyio.py	73893	0644	edit dl rm
_sitebuiltins.py	3115	0644	edit dl rm
_strptime.py	22053	0644	edit dl rm
_sysconfigdata.py	24480	0644	edit dl rm
_threading_local.py	7410	0644	edit dl rm
_weakrefset.py	5705	0644	edit dl rm
__future__.py	4584	0644	edit dl rm
__phello__.foo.py	64	0644	edit dl rm

Edit: /opt/alt/python34/lib64/python3.4/poplib.py (14319B)

"""A POP3 client class.

Based on the J. Myers POP3 draft, Jan. 96
"""

# Author: David Ascher <david_ascher@brown.edu>
#         [heavily stealing from nntplib.py]
# Updated: Piers Lauder <piers@cs.su.oz.au> [Jul '97]
# String method conversion and test jig improvements by ESR, February 2001.
# Added the POP3_SSL class. Methods loosely based on IMAP_SSL. Hector Urtubia <urtubia@mrbook.org> Aug 2003

# Example (see the test function at the end of this file)

# Imports

import errno
import re
import socket

try:
    import ssl
    HAVE_SSL = True
except ImportError:
    HAVE_SSL = False

__all__ = ["POP3","error_proto"]

# Exception raised when an error or invalid response is received:

class error_proto(Exception): pass

# Standard Port
POP3_PORT = 110

# POP SSL PORT
POP3_SSL_PORT = 995

# Line terminators (we always output CRLF, but accept any of CRLF, LFCR, LF)
CR = b'\r'
LF = b'\n'
CRLF = CR+LF

# maximal line length when calling readline(). This is to prevent
# reading arbitrary length lines. RFC 1939 limits POP3 line length to
# 512 characters, including CRLF. We have selected 2048 just to be on
# the safe side.
_MAXLINE = 2048

class POP3:

"""This class supports both the minimal and optional command sets.
    Arguments can be strings or integers (where appropriate)
    (e.g.: retr(1) and retr('1') both work equally well.

Minimal Command Set:
            USER name               user(name)
            PASS string             pass_(string)
            STAT                    stat()
            LIST [msg]              list(msg = None)
            RETR msg                retr(msg)
            DELE msg                dele(msg)
            NOOP                    noop()
            RSET                    rset()
            QUIT                    quit()

Optional Commands (some servers support these):
            RPOP name               rpop(name)
            APOP name digest        apop(name, digest)
            TOP msg n               top(msg, n)
            UIDL [msg]              uidl(msg = None)
            CAPA                    capa()
            STLS                    stls()

Raises one exception: 'error_proto'.

Instantiate with:
            POP3(hostname, port=110)

NB:     the POP protocol locks the mailbox from user
            authorization until QUIT, so be sure to get in, suck
            the messages, and quit, each time you access the
            mailbox.

POP is a line-based protocol, which means large mail
            messages consume lots of python cycles reading them
            line-by-line.

If it's available on your mail server, use IMAP4
            instead, it doesn't suffer from the two problems
            above.
    """

encoding = 'UTF-8'

def __init__(self, host, port=POP3_PORT,
                 timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
        self.host = host
        self.port = port
        self._tls_established = False
        self.sock = self._create_socket(timeout)
        self.file = self.sock.makefile('rb')
        self._debugging = 0
        self.welcome = self._getresp()

def _create_socket(self, timeout):
        return socket.create_connection((self.host, self.port), timeout)

def _putline(self, line):
        if self._debugging > 1: print('*put*', repr(line))
        self.sock.sendall(line + CRLF)

# Internal: send one command to the server (through _putline())

def _putcmd(self, line):
        if self._debugging: print('*cmd*', repr(line))
        line = bytes(line, self.encoding)
        self._putline(line)

# Internal: return one line from the server, stripping CRLF.
    # This is where all the CPU time of this module is consumed.
    # Raise error_proto('-ERR EOF') if the connection is closed.

def _getline(self):
        line = self.file.readline(_MAXLINE + 1)
        if len(line) > _MAXLINE:
            raise error_proto('line too long')

if self._debugging > 1: print('*get*', repr(line))
        if not line: raise error_proto('-ERR EOF')
        octets = len(line)
        # server can send any combination of CR & LF
        # however, 'readline()' returns lines ending in LF
        # so only possibilities are ...LF, ...CRLF, CR...LF
        if line[-2:] == CRLF:
            return line[:-2], octets
        if line[:1] == CR:
            return line[1:-1], octets
        return line[:-1], octets

# Internal: get a response from the server.
    # Raise 'error_proto' if the response doesn't start with '+'.

def _getresp(self):
        resp, o = self._getline()
        if self._debugging > 1: print('*resp*', repr(resp))
        if not resp.startswith(b'+'):
            raise error_proto(resp)
        return resp

# Internal: get a response plus following text from the server.

def _getlongresp(self):
        resp = self._getresp()
        list = []; octets = 0
        line, o = self._getline()
        while line != b'.':
            if line.startswith(b'..'):
                o = o-1
                line = line[1:]
            octets = octets + o
            list.append(line)
            line, o = self._getline()
        return resp, list, octets

# Internal: send a command and get the response

def _shortcmd(self, line):
        self._putcmd(line)
        return self._getresp()

# Internal: send a command and get the response plus following text

def _longcmd(self, line):
        self._putcmd(line)
        return self._getlongresp()

# These can be useful:

def getwelcome(self):
        return self.welcome

def set_debuglevel(self, level):
        self._debugging = level

# Here are all the POP commands:

def user(self, user):
        """Send user name, return response

(should indicate password required).
        """
        return self._shortcmd('USER %s' % user)

def pass_(self, pswd):
        """Send password, return response

(response includes message count, mailbox size).

NB: mailbox is locked by server from here to 'quit()'
        """
        return self._shortcmd('PASS %s' % pswd)

def stat(self):
        """Get mailbox status.

Result is tuple of 2 ints (message count, mailbox size)
        """
        retval = self._shortcmd('STAT')
        rets = retval.split()
        if self._debugging: print('*stat*', repr(rets))
        numMessages = int(rets[1])
        sizeMessages = int(rets[2])
        return (numMessages, sizeMessages)

def list(self, which=None):
        """Request listing, return result.

Result without a message number argument is in form
        ['response', ['mesg_num octets', ...], octets].

Result when a message number argument is given is a
        single response: the "scan listing" for that message.
        """
        if which is not None:
            return self._shortcmd('LIST %s' % which)
        return self._longcmd('LIST')

def retr(self, which):
        """Retrieve whole message number 'which'.

Result is in form ['response', ['line', ...], octets].
        """
        return self._longcmd('RETR %s' % which)

def dele(self, which):
        """Delete message number 'which'.

Result is 'response'.
        """
        return self._shortcmd('DELE %s' % which)

def noop(self):
        """Does nothing.

One supposes the response indicates the server is alive.
        """
        return self._shortcmd('NOOP')

def rset(self):
        """Unmark all messages marked for deletion."""
        return self._shortcmd('RSET')

def quit(self):
        """Signoff: commit changes on server, unlock mailbox, close connection."""
        resp = self._shortcmd('QUIT')
        self.close()
        return resp

def close(self):
        """Close the connection without assuming anything about it."""
        try:
            file = self.file
            self.file = None
            if file is not None:
                file.close()
        finally:
            sock = self.sock
            self.sock = None
            if sock is not None:
                try:
                    sock.shutdown(socket.SHUT_RDWR)
                except OSError as e:
                    # The server might already have closed the connection
                    if e.errno != errno.ENOTCONN:
                        raise
                finally:
                    sock.close()

#__del__ = quit

# optional commands:

def rpop(self, user):
        """Not sure what this does."""
        return self._shortcmd('RPOP %s' % user)

timestamp = re.compile(br'\+OK.[^<]*(<.*>)')

def apop(self, user, password):
        """Authorisation

- only possible if server has supplied a timestamp in initial greeting.

Args:
                user     - mailbox user;
                password - mailbox password.

NB: mailbox is locked by server from here to 'quit()'
        """
        secret = bytes(password, self.encoding)
        m = self.timestamp.match(self.welcome)
        if not m:
            raise error_proto('-ERR APOP not supported by server')
        import hashlib
        digest = m.group(1)+secret
        digest = hashlib.md5(digest).hexdigest()
        return self._shortcmd('APOP %s %s' % (user, digest))

def top(self, which, howmuch):
        """Retrieve message header of message number 'which'
        and first 'howmuch' lines of message body.

Result is in form ['response', ['line', ...], octets].
        """
        return self._longcmd('TOP %s %s' % (which, howmuch))

def uidl(self, which=None):
        """Return message digest (unique id) list.

If 'which', result contains unique id for that message
        in the form 'response mesgnum uid', otherwise result is
        the list ['response', ['mesgnum uid', ...], octets]
        """
        if which is not None:
            return self._shortcmd('UIDL %s' % which)
        return self._longcmd('UIDL')

def capa(self):
        """Return server capabilities (RFC 2449) as a dictionary
        >>> c=poplib.POP3('localhost')
        >>> c.capa()
        {'IMPLEMENTATION': ['Cyrus', 'POP3', 'server', 'v2.2.12'],
         'TOP': [], 'LOGIN-DELAY': ['0'], 'AUTH-RESP-CODE': [],
         'EXPIRE': ['NEVER'], 'USER': [], 'STLS': [], 'PIPELINING': [],
         'UIDL': [], 'RESP-CODES': []}
        >>>

Really, according to RFC 2449, the cyrus folks should avoid
        having the implementation split into multiple arguments...
        """
        def _parsecap(line):
            lst = line.decode('ascii').split()
            return lst[0], lst[1:]

caps = {}
        try:
            resp = self._longcmd('CAPA')
            rawcaps = resp[1]
            for capline in rawcaps:
                capnm, capargs = _parsecap(capline)
                caps[capnm] = capargs
        except error_proto as _err:
            raise error_proto('-ERR CAPA not supported by server')
        return caps

def stls(self, context=None):
        """Start a TLS session on the active connection as specified in RFC 2595.

context - a ssl.SSLContext
        """
        if not HAVE_SSL:
            raise error_proto('-ERR TLS support missing')
        if self._tls_established:
            raise error_proto('-ERR TLS session already established')
        caps = self.capa()
        if not 'STLS' in caps:
            raise error_proto('-ERR STLS not supported by server')
        if context is None:
            context = ssl._create_stdlib_context()
        resp = self._shortcmd('STLS')
        self.sock = context.wrap_socket(self.sock,
                                        server_hostname=self.host)
        self.file = self.sock.makefile('rb')
        self._tls_established = True
        return resp

if HAVE_SSL:

class POP3_SSL(POP3):
        """POP3 client class over SSL connection

Instantiate with: POP3_SSL(hostname, port=995, keyfile=None, certfile=None,
                                   context=None)

hostname - the hostname of the pop3 over ssl server
               port - port number
               keyfile - PEM formatted file that contains your private key
               certfile - PEM formatted certificate chain file
               context - a ssl.SSLContext

See the methods of the parent class POP3 for more documentation.
        """

def __init__(self, host, port=POP3_SSL_PORT, keyfile=None, certfile=None,
                     timeout=socket._GLOBAL_DEFAULT_TIMEOUT, context=None):
            if context is not None and keyfile is not None:
                raise ValueError("context and keyfile arguments are mutually "
                                 "exclusive")
            if context is not None and certfile is not None:
                raise ValueError("context and certfile arguments are mutually "
                                 "exclusive")
            self.keyfile = keyfile
            self.certfile = certfile
            if context is None:
                context = ssl._create_stdlib_context(certfile=certfile,
                                                     keyfile=keyfile)
            self.context = context
            POP3.__init__(self, host, port, timeout)

def _create_socket(self, timeout):
            sock = POP3._create_socket(self, timeout)
            sock = self.context.wrap_socket(sock,
                                            server_hostname=self.host)
            return sock

def stls(self, keyfile=None, certfile=None, context=None):
            """The method unconditionally raises an exception since the
            STLS command doesn't make any sense on an already established
            SSL/TLS session.
            """
            raise error_proto('-ERR TLS session already established')

__all__.append("POP3_SSL")

if __name__ == "__main__":
    import sys
    a = POP3(sys.argv[1])
    print(a.getwelcome())
    a.user(sys.argv[2])
    a.pass_(sys.argv[3])
    a.list()
    (numMsgs, totalSize) = a.stat()
    for i in range(1, numMsgs + 1):
        (header, msg, octets) = a.retr(i)
        print("Message %d:" % i)
        for line in msg:
            print('   ' + line)
        print('-----------------------')
    a.quit()

cmd: