__ __ __ __ _____ _ _ _____ _ _ _ | \/ | \ \ / / | __ \ (_) | | / ____| | | | | | \ / |_ __\ V / | |__) | __ ___ ____ _| |_ ___ | (___ | |__ ___| | | | |\/| | '__|> < | ___/ '__| \ \ / / _` | __/ _ \ \___ \| '_ \ / _ \ | | | | | | |_ / . \ | | | | | |\ V / (_| | || __/ ____) | | | | __/ | | |_| |_|_(_)_/ \_\ |_| |_| |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1 if you need WebShell for Seo everyday contact me on Telegram Telegram Address : @jackleetFor_More_Tools:
# -*- 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
warnings.warn(
'The asyncore module is deprecated and will be removed in Python 3.12. '
'The recommended replacement is asyncio',
DeprecationWarning,
stacklevel=2)
_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.errno 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(False)
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.errno 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))
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(False)
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.errno 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.errno == EWOULDBLOCK:
return 0
elif why.errno 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.errno 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.errno 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.errno == 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()
| Name | Type | Size | Permission | Actions |
|---|---|---|---|---|
| __pycache__ | Folder | 0755 |
|
|
| asyncio | Folder | 0755 |
|
|
| collections | Folder | 0755 |
|
|
| concurrent | Folder | 0755 |
|
|
| config-3.10-x86_64-linux-gnu | Folder | 0755 |
|
|
| ctypes | Folder | 0755 |
|
|
| curses | Folder | 0755 |
|
|
| dbm | Folder | 0755 |
|
|
| distutils | Folder | 0755 |
|
|
| Folder | 0755 |
|
||
| encodings | Folder | 0755 |
|
|
| html | Folder | 0755 |
|
|
| http | Folder | 0755 |
|
|
| importlib | Folder | 0755 |
|
|
| json | Folder | 0755 |
|
|
| lib-dynload | Folder | 0755 |
|
|
| lib2to3 | Folder | 0755 |
|
|
| logging | Folder | 0755 |
|
|
| multiprocessing | Folder | 0755 |
|
|
| pydoc_data | Folder | 0755 |
|
|
| sqlite3 | Folder | 0755 |
|
|
| test | Folder | 0755 |
|
|
| unittest | Folder | 0755 |
|
|
| urllib | Folder | 0755 |
|
|
| venv | Folder | 0755 |
|
|
| wsgiref | Folder | 0755 |
|
|
| xml | Folder | 0755 |
|
|
| xmlrpc | Folder | 0755 |
|
|
| zoneinfo | Folder | 0755 |
|
|
| LICENSE.txt | File | 13.61 KB | 0644 |
|
| __future__.py | File | 5.03 KB | 0644 |
|
| __phello__.foo.py | File | 64 B | 0644 |
|
| _aix_support.py | File | 3.19 KB | 0644 |
|
| _bootsubprocess.py | File | 2.61 KB | 0644 |
|
| _collections_abc.py | File | 31.53 KB | 0644 |
|
| _compat_pickle.py | File | 8.54 KB | 0644 |
|
| _compression.py | File | 5.55 KB | 0644 |
|
| _distutils_system_mod.py | File | 6.16 KB | 0644 |
|
| _markupbase.py | File | 14.31 KB | 0644 |
|
| _osx_support.py | File | 21.28 KB | 0644 |
|
| _py_abc.py | File | 6.04 KB | 0644 |
|
| _pydecimal.py | File | 223.32 KB | 0644 |
|
| _pyio.py | File | 92.25 KB | 0644 |
|
| _sitebuiltins.py | File | 3.05 KB | 0644 |
|
| _strptime.py | File | 24.68 KB | 0644 |
|
| _sysconfigdata__linux_x86_64-linux-gnu.py | File | 26.84 KB | 0644 |
|
| _sysconfigdata__x86_64-linux-gnu.py | File | 26.84 KB | 0644 |
|
| _threading_local.py | File | 7.05 KB | 0644 |
|
| _weakrefset.py | File | 5.78 KB | 0644 |
|
| abc.py | File | 6.37 KB | 0644 |
|
| aifc.py | File | 31.84 KB | 0644 |
|
| antigravity.py | File | 500 B | 0644 |
|
| argparse.py | File | 96.52 KB | 0644 |
|
| ast.py | File | 58.5 KB | 0644 |
|
| asynchat.py | File | 11.25 KB | 0644 |
|
| asyncore.py | File | 19.79 KB | 0644 |
|
| base64.py | File | 20.36 KB | 0755 |
|
| bdb.py | File | 31.64 KB | 0644 |
|
| binhex.py | File | 14.44 KB | 0644 |
|
| bisect.py | File | 3.06 KB | 0644 |
|
| bz2.py | File | 11.57 KB | 0644 |
|
| cProfile.py | File | 6.2 KB | 0755 |
|
| calendar.py | File | 24 KB | 0644 |
|
| cgi.py | File | 33.3 KB | 0755 |
|
| cgitb.py | File | 11.81 KB | 0644 |
|
| chunk.py | File | 5.31 KB | 0644 |
|
| cmd.py | File | 14.51 KB | 0644 |
|
| code.py | File | 10.37 KB | 0644 |
|
| codecs.py | File | 35.85 KB | 0644 |
|
| codeop.py | File | 5.48 KB | 0644 |
|
| colorsys.py | File | 3.92 KB | 0644 |
|
| compileall.py | File | 19.78 KB | 0644 |
|
| configparser.py | File | 53.33 KB | 0644 |
|
| contextlib.py | File | 25.28 KB | 0644 |
|
| contextvars.py | File | 129 B | 0644 |
|
| copy.py | File | 8.48 KB | 0644 |
|
| copyreg.py | File | 7.25 KB | 0644 |
|
| crypt.py | File | 3.76 KB | 0644 |
|
| csv.py | File | 15.65 KB | 0644 |
|
| dataclasses.py | File | 55.07 KB | 0644 |
|
| datetime.py | File | 86.02 KB | 0644 |
|
| decimal.py | File | 320 B | 0644 |
|
| difflib.py | File | 81.36 KB | 0644 |
|
| dis.py | File | 19.55 KB | 0644 |
|
| doctest.py | File | 102.68 KB | 0644 |
|
| enum.py | File | 38.9 KB | 0644 |
|
| filecmp.py | File | 9.94 KB | 0644 |
|
| fileinput.py | File | 16.06 KB | 0644 |
|
| fnmatch.py | File | 6.56 KB | 0644 |
|
| fractions.py | File | 27.58 KB | 0644 |
|
| ftplib.py | File | 34.66 KB | 0644 |
|
| functools.py | File | 37.18 KB | 0644 |
|
| genericpath.py | File | 4.86 KB | 0644 |
|
| getopt.py | File | 7.31 KB | 0644 |
|
| getpass.py | File | 5.85 KB | 0644 |
|
| gettext.py | File | 27.04 KB | 0644 |
|
| glob.py | File | 7.7 KB | 0644 |
|
| graphlib.py | File | 9.35 KB | 0644 |
|
| gzip.py | File | 21.34 KB | 0644 |
|
| hashlib.py | File | 9.99 KB | 0644 |
|
| heapq.py | File | 22.34 KB | 0644 |
|
| hmac.py | File | 7.54 KB | 0644 |
|
| imaplib.py | File | 53.58 KB | 0644 |
|
| imghdr.py | File | 3.72 KB | 0644 |
|
| imp.py | File | 10.34 KB | 0644 |
|
| inspect.py | File | 121.46 KB | 0644 |
|
| io.py | File | 4.1 KB | 0644 |
|
| ipaddress.py | File | 75.96 KB | 0644 |
|
| keyword.py | File | 1.04 KB | 0644 |
|
| linecache.py | File | 5.56 KB | 0644 |
|
| locale.py | File | 76.3 KB | 0644 |
|
| lzma.py | File | 12.97 KB | 0644 |
|
| mailbox.py | File | 76.95 KB | 0644 |
|
| mailcap.py | File | 8.9 KB | 0644 |
|
| mimetypes.py | File | 22.01 KB | 0644 |
|
| modulefinder.py | File | 23.83 KB | 0644 |
|
| netrc.py | File | 5.61 KB | 0644 |
|
| nntplib.py | File | 40.06 KB | 0644 |
|
| ntpath.py | File | 26.92 KB | 0644 |
|
| nturl2path.py | File | 2.82 KB | 0644 |
|
| numbers.py | File | 10.11 KB | 0644 |
|
| opcode.py | File | 5.76 KB | 0644 |
|
| operator.py | File | 10.5 KB | 0644 |
|
| optparse.py | File | 58.95 KB | 0644 |
|
| os.py | File | 38.63 KB | 0644 |
|
| pathlib.py | File | 48.41 KB | 0644 |
|
| pdb.py | File | 61.74 KB | 0755 |
|
| pickle.py | File | 63.43 KB | 0644 |
|
| pickletools.py | File | 91.29 KB | 0644 |
|
| pipes.py | File | 8.71 KB | 0644 |
|
| pkgutil.py | File | 24 KB | 0644 |
|
| platform.py | File | 41.04 KB | 0755 |
|
| plistlib.py | File | 27.69 KB | 0644 |
|
| poplib.py | File | 14.84 KB | 0644 |
|
| posixpath.py | File | 15.75 KB | 0644 |
|
| pprint.py | File | 23.87 KB | 0644 |
|
| profile.py | File | 22.35 KB | 0755 |
|
| pstats.py | File | 28.64 KB | 0644 |
|
| pty.py | File | 5.09 KB | 0644 |
|
| py_compile.py | File | 7.69 KB | 0644 |
|
| pyclbr.py | File | 11.13 KB | 0644 |
|
| pydoc.py | File | 107.31 KB | 0755 |
|
| queue.py | File | 11.23 KB | 0644 |
|
| quopri.py | File | 7.1 KB | 0755 |
|
| random.py | File | 32.44 KB | 0644 |
|
| re.py | File | 15.49 KB | 0644 |
|
| reprlib.py | File | 5.14 KB | 0644 |
|
| rlcompleter.py | File | 7.63 KB | 0644 |
|
| runpy.py | File | 12.8 KB | 0644 |
|
| sched.py | File | 6.2 KB | 0644 |
|
| secrets.py | File | 1.99 KB | 0644 |
|
| selectors.py | File | 19.08 KB | 0644 |
|
| shelve.py | File | 8.36 KB | 0644 |
|
| shlex.py | File | 13.18 KB | 0644 |
|
| shutil.py | File | 53.29 KB | 0644 |
|
| signal.py | File | 2.38 KB | 0644 |
|
| site.py | File | 23.11 KB | 0644 |
|
| sitecustomize.py | File | 155 B | 0644 |
|
| smtpd.py | File | 34.34 KB | 0755 |
|
| smtplib.py | File | 44.35 KB | 0755 |
|
| sndhdr.py | File | 6.93 KB | 0644 |
|
| socket.py | File | 35.92 KB | 0644 |
|
| socketserver.py | File | 26.66 KB | 0644 |
|
| sre_compile.py | File | 27.32 KB | 0644 |
|
| sre_constants.py | File | 7.01 KB | 0644 |
|
| sre_parse.py | File | 39.82 KB | 0644 |
|
| ssl.py | File | 52.47 KB | 0644 |
|
| stat.py | File | 5.36 KB | 0644 |
|
| statistics.py | File | 42.19 KB | 0644 |
|
| string.py | File | 10.32 KB | 0644 |
|
| stringprep.py | File | 12.61 KB | 0644 |
|
| struct.py | File | 257 B | 0644 |
|
| subprocess.py | File | 82.93 KB | 0644 |
|
| sunau.py | File | 17.73 KB | 0644 |
|
| symtable.py | File | 9.98 KB | 0644 |
|
| sysconfig.py | File | 28.71 KB | 0644 |
|
| tabnanny.py | File | 11.03 KB | 0755 |
|
| tarfile.py | File | 104.93 KB | 0755 |
|
| telnetlib.py | File | 22.71 KB | 0644 |
|
| tempfile.py | File | 33.76 KB | 0644 |
|
| textwrap.py | File | 19.31 KB | 0644 |
|
| this.py | File | 1003 B | 0644 |
|
| threading.py | File | 55.86 KB | 0644 |
|
| timeit.py | File | 13.18 KB | 0755 |
|
| token.py | File | 2.33 KB | 0644 |
|
| tokenize.py | File | 25.31 KB | 0644 |
|
| trace.py | File | 28.53 KB | 0755 |
|
| traceback.py | File | 25.61 KB | 0644 |
|
| tracemalloc.py | File | 17.62 KB | 0644 |
|
| tty.py | File | 879 B | 0644 |
|
| turtle.py | File | 140.39 KB | 0644 |
|
| types.py | File | 9.88 KB | 0644 |
|
| typing.py | File | 90.39 KB | 0644 |
|
| uu.py | File | 7.13 KB | 0755 |
|
| uuid.py | File | 26.86 KB | 0644 |
|
| warnings.py | File | 19.23 KB | 0644 |
|
| wave.py | File | 17.58 KB | 0644 |
|
| weakref.py | File | 21.05 KB | 0644 |
|
| webbrowser.py | File | 23.68 KB | 0755 |
|
| xdrlib.py | File | 5.77 KB | 0644 |
|
| zipapp.py | File | 7.36 KB | 0644 |
|
| zipfile.py | File | 88.72 KB | 0644 |
|
| zipimport.py | File | 30.17 KB | 0644 |
|