Na}{

Path: ~//opt/alt/python37/lib64/python3.7/

File Content: `asyncore.py`

# -*- Mode: Python -*-
#   Id: asyncore.py,v 2.51 2000/09/07 22:29:26 rushing Exp
#   Author: Sam Rushing <rushing@nightmare.com>

# ======================================================================
# Copyright 1996 by Sam Rushing
#
#                         All Rights Reserved
#
# Permission to use, copy, modify, and distribute this software and
# its documentation for any purpose and without fee is hereby
# granted, provided that the above copyright notice appear in all
# copies and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of Sam
# Rushing not be used in advertising or publicity pertaining to
# distribution of the software without specific, written prior
# permission.
#
# SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
# NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR
# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
# ======================================================================

"""Basic infrastructure for asynchronous socket service clients and servers.

There are only two ways to have a program on a single processor do "more
than one thing at a time".  Multi-threaded programming is the simplest and
most popular way to do it, but there is another very different technique,
that lets you have nearly all the advantages of multi-threading, without
actually using multiple threads. it's really only practical if your program
is largely I/O bound. If your program is CPU bound, then pre-emptive
scheduled threads are probably what you really need. Network servers are
rarely CPU-bound, however.

If your operating system supports the select() system call in its I/O
library (and nearly all do), then you can use it to juggle multiple
communication channels at once; doing other work while your I/O is taking
place in the "background."  Although this strategy can seem strange and
complex, especially at first, it is in many ways easier to understand and
control than multi-threaded programming. The module documented here solves
many of the difficult problems for you, making the task of building
sophisticated high-performance network servers and clients a snap.
"""

import select
import socket
import sys
import time
import warnings

import os
from errno import EALREADY, EINPROGRESS, EWOULDBLOCK, ECONNRESET, EINVAL, \
     ENOTCONN, ESHUTDOWN, EISCONN, EBADF, ECONNABORTED, EPIPE, EAGAIN, \
     errorcode

_DISCONNECTED = frozenset({ECONNRESET, ENOTCONN, ESHUTDOWN, ECONNABORTED, EPIPE,
                           EBADF})

try:
    socket_map
except NameError:
    socket_map = {}

def _strerror(err):
    try:
        return os.strerror(err)
    except (ValueError, OverflowError, NameError):
        if err in errorcode:
            return errorcode[err]
        return "Unknown error %s" %err

class ExitNow(Exception):
    pass

_reraised_exceptions = (ExitNow, KeyboardInterrupt, SystemExit)

def read(obj):
    try:
        obj.handle_read_event()
    except _reraised_exceptions:
        raise
    except:
        obj.handle_error()

def write(obj):
    try:
        obj.handle_write_event()
    except _reraised_exceptions:
        raise
    except:
        obj.handle_error()

def _exception(obj):
    try:
        obj.handle_expt_event()
    except _reraised_exceptions:
        raise
    except:
        obj.handle_error()

def readwrite(obj, flags):
    try:
        if flags & select.POLLIN:
            obj.handle_read_event()
        if flags & select.POLLOUT:
            obj.handle_write_event()
        if flags & select.POLLPRI:
            obj.handle_expt_event()
        if flags & (select.POLLHUP | select.POLLERR | select.POLLNVAL):
            obj.handle_close()
    except OSError as e:
        if e.args[0] not in _DISCONNECTED:
            obj.handle_error()
        else:
            obj.handle_close()
    except _reraised_exceptions:
        raise
    except:
        obj.handle_error()

def poll(timeout=0.0, map=None):
    if map is None:
        map = socket_map
    if map:
        r = []; w = []; e = []
        for fd, obj in list(map.items()):
            is_r = obj.readable()
            is_w = obj.writable()
            if is_r:
                r.append(fd)
            # accepting sockets should not be writable
            if is_w and not obj.accepting:
                w.append(fd)
            if is_r or is_w:
                e.append(fd)
        if [] == r == w == e:
            time.sleep(timeout)
            return

        r, w, e = select.select(r, w, e, timeout)

        for fd in r:
            obj = map.get(fd)
            if obj is None:
                continue
            read(obj)

        for fd in w:
            obj = map.get(fd)
            if obj is None:
                continue
            write(obj)

        for fd in e:
            obj = map.get(fd)
            if obj is None:
                continue
            _exception(obj)

def poll2(timeout=0.0, map=None):
    # Use the poll() support added to the select module in Python 2.0
    if map is None:
        map = socket_map
    if timeout is not None:
        # timeout is in milliseconds
        timeout = int(timeout*1000)
    pollster = select.poll()
    if map:
        for fd, obj in list(map.items()):
            flags = 0
            if obj.readable():
                flags |= select.POLLIN | select.POLLPRI
            # accepting sockets should not be writable
            if obj.writable() and not obj.accepting:
                flags |= select.POLLOUT
            if flags:
                pollster.register(fd, flags)

        r = pollster.poll(timeout)
        for fd, flags in r:
            obj = map.get(fd)
            if obj is None:
                continue
            readwrite(obj, flags)

poll3 = poll2                           # Alias for backward compatibility

def loop(timeout=30.0, use_poll=False, map=None, count=None):
    if map is None:
        map = socket_map

    if use_poll and hasattr(select, 'poll'):
        poll_fun = poll2
    else:
        poll_fun = poll

    if count is None:
        while map:
            poll_fun(timeout, map)

    else:
        while map and count > 0:
            poll_fun(timeout, map)
            count = count - 1

class dispatcher:

    debug = False
    connected = False
    accepting = False
    connecting = False
    closing = False
    addr = None
    ignore_log_types = frozenset({'warning'})

    def __init__(self, sock=None, map=None):
        if map is None:
            self._map = socket_map
        else:
            self._map = map

        self._fileno = None

        if sock:
            # Set to nonblocking just to make sure for cases where we
            # get a socket from a blocking source.
            sock.setblocking(0)
            self.set_socket(sock, map)
            self.connected = True
            # The constructor no longer requires that the socket
            # passed be connected.
            try:
                self.addr = sock.getpeername()
            except OSError as err:
                if err.args[0] in (ENOTCONN, EINVAL):
                    # To handle the case where we got an unconnected
                    # socket.
                    self.connected = False
                else:
                    # The socket is broken in some unknown way, alert
                    # the user and remove it from the map (to prevent
                    # polling of broken sockets).
                    self.del_channel(map)
                    raise
        else:
            self.socket = None

    def __repr__(self):
        status = [self.__class__.__module__+"."+self.__class__.__qualname__]
        if self.accepting and self.addr:
            status.append('listening')
        elif self.connected:
            status.append('connected')
        if self.addr is not None:
            try:
                status.append('%s:%d' % self.addr)
            except TypeError:
                status.append(repr(self.addr))
        return '<%s at %#x>' % (' '.join(status), id(self))

    __str__ = __repr__

    def add_channel(self, map=None):
        #self.log_info('adding channel %s' % self)
        if map is None:
            map = self._map
        map[self._fileno] = self

    def del_channel(self, map=None):
        fd = self._fileno
        if map is None:
            map = self._map
        if fd in map:
            #self.log_info('closing channel %d:%s' % (fd, self))
            del map[fd]
        self._fileno = None

    def create_socket(self, family=socket.AF_INET, type=socket.SOCK_STREAM):
        self.family_and_type = family, type
        sock = socket.socket(family, type)
        sock.setblocking(0)
        self.set_socket(sock)

    def set_socket(self, sock, map=None):
        self.socket = sock
        self._fileno = sock.fileno()
        self.add_channel(map)

    def set_reuse_addr(self):
        # try to re-use a server port if possible
        try:
            self.socket.setsockopt(
                socket.SOL_SOCKET, socket.SO_REUSEADDR,
                self.socket.getsockopt(socket.SOL_SOCKET,
                                       socket.SO_REUSEADDR) | 1
                )
        except OSError:
            pass

    # ==================================================
    # predicates for select()
    # these are used as filters for the lists of sockets
    # to pass to select().
    # ==================================================

    def readable(self):
        return True

    def writable(self):
        return True

    # ==================================================
    # socket object methods.
    # ==================================================

    def listen(self, num):
        self.accepting = True
        if os.name == 'nt' and num > 5:
            num = 5
        return self.socket.listen(num)

    def bind(self, addr):
        self.addr = addr
        return self.socket.bind(addr)

    def connect(self, address):
        self.connected = False
        self.connecting = True
        err = self.socket.connect_ex(address)
        if err in (EINPROGRESS, EALREADY, EWOULDBLOCK) \
        or err == EINVAL and os.name == 'nt':
            self.addr = address
            return
        if err in (0, EISCONN):
            self.addr = address
            self.handle_connect_event()
        else:
            raise OSError(err, errorcode[err])

    def accept(self):
        # XXX can return either an address pair or None
        try:
            conn, addr = self.socket.accept()
        except TypeError:
            return None
        except OSError as why:
            if why.args[0] in (EWOULDBLOCK, ECONNABORTED, EAGAIN):
                return None
            else:
                raise
        else:
            return conn, addr

    def send(self, data):
        try:
            result = self.socket.send(data)
            return result
        except OSError as why:
            if why.args[0] == EWOULDBLOCK:
                return 0
            elif why.args[0] in _DISCONNECTED:
                self.handle_close()
                return 0
            else:
                raise

    def recv(self, buffer_size):
        try:
            data = self.socket.recv(buffer_size)
            if not data:
                # a closed connection is indicated by signaling
                # a read condition, and having recv() return 0.
                self.handle_close()
                return b''
            else:
                return data
        except OSError as why:
            # winsock sometimes raises ENOTCONN
            if why.args[0] in _DISCONNECTED:
                self.handle_close()
                return b''
            else:
                raise

    def close(self):
        self.connected = False
        self.accepting = False
        self.connecting = False
        self.del_channel()
        if self.socket is not None:
            try:
                self.socket.close()
            except OSError as why:
                if why.args[0] not in (ENOTCONN, EBADF):
                    raise

    # log and log_info may be overridden to provide more sophisticated
    # logging and warning methods. In general, log is for 'hit' logging
    # and 'log_info' is for informational, warning and error logging.

    def log(self, message):
        sys.stderr.write('log: %s\n' % str(message))

    def log_info(self, message, type='info'):
        if type not in self.ignore_log_types:
            print('%s: %s' % (type, message))

    def handle_read_event(self):
        if self.accepting:
            # accepting sockets are never connected, they "spawn" new
            # sockets that are connected
            self.handle_accept()
        elif not self.connected:
            if self.connecting:
                self.handle_connect_event()
            self.handle_read()
        else:
            self.handle_read()

    def handle_connect_event(self):
        err = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
        if err != 0:
            raise OSError(err, _strerror(err))
        self.handle_connect()
        self.connected = True
        self.connecting = False

    def handle_write_event(self):
        if self.accepting:
            # Accepting sockets shouldn't get a write event.
            # We will pretend it didn't happen.
            return

        if not self.connected:
            if self.connecting:
                self.handle_connect_event()
        self.handle_write()

    def handle_expt_event(self):
        # handle_expt_event() is called if there might be an error on the
        # socket, or if there is OOB data
        # check for the error condition first
        err = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
        if err != 0:
            # we can get here when select.select() says that there is an
            # exceptional condition on the socket
            # since there is an error, we'll go ahead and close the socket
            # like we would in a subclassed handle_read() that received no
            # data
            self.handle_close()
        else:
            self.handle_expt()

    def handle_error(self):
        nil, t, v, tbinfo = compact_traceback()

        # sometimes a user repr method will crash.
        try:
            self_repr = repr(self)
        except:
            self_repr = '<__repr__(self) failed for object at %0x>' % id(self)

        self.log_info(
            'uncaptured python exception, closing channel %s (%s:%s %s)' % (
                self_repr,
                t,
                v,
                tbinfo
                ),
            'error'
            )
        self.handle_close()

    def handle_expt(self):
        self.log_info('unhandled incoming priority event', 'warning')

    def handle_read(self):
        self.log_info('unhandled read event', 'warning')

    def handle_write(self):
        self.log_info('unhandled write event', 'warning')

    def handle_connect(self):
        self.log_info('unhandled connect event', 'warning')

    def handle_accept(self):
        pair = self.accept()
        if pair is not None:
            self.handle_accepted(*pair)

    def handle_accepted(self, sock, addr):
        sock.close()
        self.log_info('unhandled accepted event', 'warning')

    def handle_close(self):
        self.log_info('unhandled close event', 'warning')
        self.close()

# ---------------------------------------------------------------------------
# adds simple buffered output capability, useful for simple clients.
# [for more sophisticated usage use asynchat.async_chat]
# ---------------------------------------------------------------------------

class dispatcher_with_send(dispatcher):

    def __init__(self, sock=None, map=None):
        dispatcher.__init__(self, sock, map)
        self.out_buffer = b''

    def initiate_send(self):
        num_sent = 0
        num_sent = dispatcher.send(self, self.out_buffer[:65536])
        self.out_buffer = self.out_buffer[num_sent:]

    def handle_write(self):
        self.initiate_send()

    def writable(self):
        return (not self.connected) or len(self.out_buffer)

    def send(self, data):
        if self.debug:
            self.log_info('sending %s' % repr(data))
        self.out_buffer = self.out_buffer + data
        self.initiate_send()

# ---------------------------------------------------------------------------
# used for debugging.
# ---------------------------------------------------------------------------

def compact_traceback():
    t, v, tb = sys.exc_info()
    tbinfo = []
    if not tb: # Must have a traceback
        raise AssertionError("traceback does not exist")
    while tb:
        tbinfo.append((
            tb.tb_frame.f_code.co_filename,
            tb.tb_frame.f_code.co_name,
            str(tb.tb_lineno)
            ))
        tb = tb.tb_next

    # just to be safe
    del tb

    file, function, line = tbinfo[-1]
    info = ' '.join(['[%s|%s|%s]' % x for x in tbinfo])
    return (file, function, line), t, v, info

def close_all(map=None, ignore_all=False):
    if map is None:
        map = socket_map
    for x in list(map.values()):
        try:
            x.close()
        except OSError as x:
            if x.args[0] == EBADF:
                pass
            elif not ignore_all:
                raise
        except _reraised_exceptions:
            raise
        except:
            if not ignore_all:
                raise
    map.clear()

# Asynchronous File I/O:
#
# After a little research (reading man pages on various unixen, and
# digging through the linux kernel), I've determined that select()
# isn't meant for doing asynchronous file i/o.
# Heartening, though - reading linux/mm/filemap.c shows that linux
# supports asynchronous read-ahead.  So _MOST_ of the time, the data
# will be sitting in memory for us already when we go to read it.
#
# What other OS's (besides NT) support async file i/o?  [VMS?]
#
# Regardless, this is useful for pipes, and stdin/stdout...

if os.name == 'posix':
    class file_wrapper:
        # Here we override just enough to make a file
        # look like a socket for the purposes of asyncore.
        # The passed fd is automatically os.dup()'d

        def __init__(self, fd):
            self.fd = os.dup(fd)

        def __del__(self):
            if self.fd >= 0:
                warnings.warn("unclosed file %r" % self, ResourceWarning,
                              source=self)
            self.close()

        def recv(self, *args):
            return os.read(self.fd, *args)

        def send(self, *args):
            return os.write(self.fd, *args)

        def getsockopt(self, level, optname, buflen=None):
            if (level == socket.SOL_SOCKET and
                optname == socket.SO_ERROR and
                not buflen):
                return 0
            raise NotImplementedError("Only asyncore specific behaviour "
                                      "implemented.")

        read = recv
        write = send

        def close(self):
            if self.fd < 0:
                return
            fd = self.fd
            self.fd = -1
            os.close(fd)

        def fileno(self):
            return self.fd

    class file_dispatcher(dispatcher):

        def __init__(self, fd, map=None):
            dispatcher.__init__(self, None, map)
            self.connected = True
            try:
                fd = fd.fileno()
            except AttributeError:
                pass
            self.set_file(fd)
            # set it to non-blocking mode
            os.set_blocking(fd, False)

        def set_file(self, fd):
            self.socket = file_wrapper(fd)
            self._fileno = self.socket.fileno()
            self.add_channel()

Edit Rename Chmod Delete

FILE FOLDER

Name	Size	Permission
__pycache__	---	0755
asyncio	---	0755
collections	---	0755
concurrent	---	0755
config-3.7m	---	0755
ctypes	---	0755
curses	---	0755
dbm	---	0755
distutils	---	0755
email	---	0755
encodings	---	0755
ensurepip	---	0755
html	---	0755
http	---	0755
idlelib	---	0755
importlib	---	0755
json	---	0755
lib-dynload	---	0755
lib2to3	---	0755
logging	---	0755
multiprocessing	---	0755
pydoc_data	---	0755
site-packages	---	0755
sqlite3	---	0755
test	---	0755
unittest	---	0755
urllib	---	0755
venv	---	0755
wsgiref	---	0755
xml	---	0755
xmlrpc	---	0755
__future__.py	5101 bytes	0644
__phello__.foo.py	64 bytes	0644
_bootlocale.py	1801 bytes	0644
_collections_abc.py	26424 bytes	0644
_compat_pickle.py	8749 bytes	0644
_compression.py	5340 bytes	0644
_dummy_thread.py	6027 bytes	0644
_markupbase.py	14598 bytes	0644
_osx_support.py	19600 bytes	0644
_py_abc.py	6186 bytes	0644
_pydecimal.py	228690 bytes	0644
_pyio.py	91616 bytes	0644
_sitebuiltins.py	3115 bytes	0644
_strptime.py	25504 bytes	0644
_sysconfigdata_dm_linux_x86_64-linux-gnu.py	26991 bytes	0644
_sysconfigdata_m_linux_x86_64-linux-gnu.py	25603 bytes	0644
_threading_local.py	7214 bytes	0644
_weakrefset.py	5679 bytes	0644
abc.py	5580 bytes	0644
aifc.py	32814 bytes	0644
antigravity.py	477 bytes	0644
argparse.py	95372 bytes	0644
ast.py	12842 bytes	0644
asynchat.py	11328 bytes	0644
asyncore.py	20118 bytes	0644
base64.py	20393 bytes	0755
bdb.py	31730 bytes	0644
binhex.py	13954 bytes	0644
bisect.py	2557 bytes	0644
bz2.py	12410 bytes	0644
cProfile.py	6253 bytes	0755
calendar.py	24826 bytes	0644
cgi.py	35050 bytes	0755
cgitb.py	12018 bytes	0644
chunk.py	5435 bytes	0644
cmd.py	14860 bytes	0644
code.py	10622 bytes	0644
codecs.py	36615 bytes	0644
codeop.py	6275 bytes	0644
colorsys.py	4064 bytes	0644
compileall.py	13788 bytes	0644
configparser.py	54283 bytes	0644
contextlib.py	24763 bytes	0644
contextvars.py	129 bytes	0644
copy.py	8856 bytes	0644
copyreg.py	7017 bytes	0644
crypt.py	3346 bytes	0644
csv.py	16180 bytes	0644
dataclasses.py	49520 bytes	0644
datetime.py	86544 bytes	0644
decimal.py	320 bytes	0644
difflib.py	84393 bytes	0644
dis.py	19888 bytes	0644
doctest.py	104560 bytes	0644
dummy_threading.py	2815 bytes	0644
enum.py	35043 bytes	0644
filecmp.py	9830 bytes	0644
fileinput.py	14625 bytes	0644
fnmatch.py	4056 bytes	0644
formatter.py	15143 bytes	0644
fractions.py	23752 bytes	0644
ftplib.py	35618 bytes	0644
functools.py	32932 bytes	0644
genericpath.py	4912 bytes	0644
getopt.py	7489 bytes	0644
getpass.py	5994 bytes	0644
gettext.py	21967 bytes	0644
glob.py	5638 bytes	0644
gzip.py	20637 bytes	0644
hashlib.py	9534 bytes	0644
heapq.py	23017 bytes	0644
hmac.py	6517 bytes	0644
imaplib.py	53292 bytes	0644
imghdr.py	3795 bytes	0644
imp.py	10536 bytes	0644
inspect.py	117635 bytes	0644
io.py	3517 bytes	0644
ipaddress.py	73578 bytes	0644
keyword.py	2256 bytes	0755
linecache.py	5330 bytes	0644
locale.py	78191 bytes	0644
lzma.py	12983 bytes	0644
macpath.py	6123 bytes	0644
mailbox.py	78654 bytes	0644
mailcap.py	8104 bytes	0644
mimetypes.py	21496 bytes	0644
modulefinder.py	23035 bytes	0644
netrc.py	5566 bytes	0644
nntplib.py	43087 bytes	0644
ntpath.py	22340 bytes	0644
nturl2path.py	2584 bytes	0644
numbers.py	10244 bytes	0644
opcode.py	5824 bytes	0644
operator.py	10863 bytes	0644
optparse.py	60371 bytes	0644
os.py	37901 bytes	0644
pathlib.py	50329 bytes	0644
pdb.py	62505 bytes	0755
pickle.py	57994 bytes	0644
pickletools.py	91220 bytes	0644
pipes.py	8916 bytes	0644
pkgutil.py	21461 bytes	0644
platform.py	46994 bytes	0755
plistlib.py	30709 bytes	0644
poplib.py	14964 bytes	0644
posixpath.py	15771 bytes	0644
pprint.py	20884 bytes	0644
profile.py	22494 bytes	0755
pstats.py	27315 bytes	0644
pty.py	4763 bytes	0644
py_compile.py	8001 bytes	0644
pyclbr.py	15137 bytes	0644
pydoc.py	105876 bytes	0644
queue.py	11359 bytes	0644
quopri.py	7265 bytes	0755
random.py	27557 bytes	0644
re.py	15306 bytes	0644
reprlib.py	5267 bytes	0644
rlcompleter.py	7097 bytes	0644
runpy.py	11959 bytes	0644
sched.py	6442 bytes	0644
secrets.py	2038 bytes	0644
selectors.py	18561 bytes	0644
shelve.py	8527 bytes	0644
shlex.py	13100 bytes	0644
shutil.py	41950 bytes	0644
signal.py	2123 bytes	0644
simple_rpm.so	11488 bytes	0755
site.py	21575 bytes	0644
smtpd.py	34722 bytes	0755
smtplib.py	44443 bytes	0755
sndhdr.py	7086 bytes	0644
socket.py	27469 bytes	0644
socketserver.py	26923 bytes	0644
sre_compile.py	26872 bytes	0644
sre_constants.py	7177 bytes	0644
sre_parse.py	39156 bytes	0644
ssl.py	45495 bytes	0644
stat.py	5391 bytes	0644
statistics.py	20651 bytes	0644
string.py	11564 bytes	0644
stringprep.py	12917 bytes	0644
struct.py	257 bytes	0644
subprocess.py	71729 bytes	0644
sunau.py	18375 bytes	0644
symbol.py	2142 bytes	0755
symtable.py	7279 bytes	0644
sysconfig.py	24440 bytes	0644
tabnanny.py	11419 bytes	0755
tarfile.py	92675 bytes	0755
telnetlib.py	23135 bytes	0644
tempfile.py	26730 bytes	0644
textwrap.py	19407 bytes	0644
this.py	1003 bytes	0644
threading.py	49284 bytes	0644
timeit.py	13493 bytes	0755
token.py	3763 bytes	0644
tokenize.py	27031 bytes	0644
trace.py	28903 bytes	0755
traceback.py	23437 bytes	0644
tracemalloc.py	17076 bytes	0644
tty.py	879 bytes	0644
types.py	9897 bytes	0644
typing.py	56438 bytes	0644
uu.py	6970 bytes	0755
uuid.py	29518 bytes	0644
warnings.py	20080 bytes	0644
wave.py	18230 bytes	0644
weakref.py	21508 bytes	0644
webbrowser.py	23715 bytes	0755
xdrlib.py	5913 bytes	0644
zipapp.py	7535 bytes	0644
zipfile.py	81094 bytes	0644

File Content: asyncore.py

File Content: `asyncore.py`