mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-05-22 21:32:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Begin incorporating Python unit tests into build

Browse source 
We now build a separate APE binary for each test so they can run in
parallel. We've got 148 tests running fast and stable so far.
This commit is contained in:
Justine Tunney 2021-09-12 21:04:44 -07:00
parent 51904e2687
commit b5f743cdc3
121 changed files with 4995 additions and 4767 deletions
Download patch file Download diff file Expand all files Collapse all files

28
third_party/python/Lib/_pyio.py vendored
View file

@ -19,33 +19,7 @@ else:
_setmode = None
import io
from io import (SEEK_SET, SEEK_CUR, SEEK_END)
__all__ = [
'BlockingIOError',
'BufferedIOBase',
'BufferedRWPair',
'BufferedRandom',
'BufferedReader',
'BufferedWriter',
'BytesIO',
'DEFAULT_BUFFER_SIZE',
'FileIO',
'IOBase',
'IncrementalNewlineDecoder',
'OpenWrapper',
'RawIOBase',
'SEEK_CUR',
'SEEK_END',
'SEEK_SET',
'StringIO',
'TextIOBase',
'TextIOWrapper',
'UnsupportedOperation',
'_io',
'abc',
'open',
]
from io import (__all__, SEEK_SET, SEEK_CUR, SEEK_END)
valid_seek_flags = {0, 1, 2} # Hardwired values
if hasattr(os, 'SEEK_HOLE') :

0
third_party/python/Lib/_sysconfigdata_m_cosmo_x86_64-cosmo.py → third_party/python/Lib/_sysconfigdata_m_cosmo_x86_64_cosmo.py vendored
View file

3
third_party/python/Lib/bisect.py vendored
View file

@ -90,3 +90,6 @@ try:
from _bisect import *
except ImportError:
pass
if __name__ == 'PYOBJ.COM':
import _bisect

5
third_party/python/Lib/cmd.py vendored
View file

@ -255,7 +255,10 @@ class Cmd:
Otherwise try to call complete_<command> to get list of completions.
"""
if state == 0:
import readline
try:
import readline
except ImportError:
return None
origline = readline.get_line_buffer()
line = origline.lstrip()
stripped = len(origline) - len(line)

109
third_party/python/Lib/collections/__init__.py vendored
View file

@ -15,21 +15,13 @@ list, set, and tuple.
'''
__all__ = ['deque', 'defaultdict', 'namedtuple', 'UserDict', 'UserList',
'UserString', 'Counter', 'OrderedDict', 'ChainMap',
'Awaitable', 'Coroutine',
'AsyncIterable', 'AsyncIterator', 'AsyncGenerator',
'Hashable', 'Iterable', 'Iterator', 'Generator', 'Reversible',
'Sized', 'Container', 'Callable', 'Collection',
'Set', 'MutableSet',
'Mapping', 'MutableMapping',
'MappingView', 'KeysView', 'ItemsView', 'ValuesView',
'Sequence', 'MutableSequence',
'ByteString']
'UserString', 'Counter', 'OrderedDict', 'ChainMap']
# For backwards compatibility, continue to make the collections ABCs
# available through the collections module.
from _collections_abc import ABCMeta, AsyncGenerator, AsyncIterable, AsyncIterator, Awaitable, ByteString, Callable, Collection, Container, Coroutine, Generator, Hashable, ItemsView, Iterable, Iterator, KeysView, Mapping, MappingView, MutableMapping, MutableSequence, MutableSet, Reversible, Sequence, Set, Sized, ValuesView, _check_methods, abstractmethod, async_generator, bytearray_iterator, bytes_iterator, coroutine, dict_itemiterator, dict_items, dict_keyiterator, dict_keys, dict_valueiterator, dict_values, generator, list_iterator, list_reverseiterator, longrange_iterator, mappingproxy, range_iterator, set_iterator, str_iterator, sys, tuple_iterator, zip_iterator
from _collections_abc import *
import _collections_abc
__all__ += _collections_abc.__all__
from operator import itemgetter as _itemgetter, eq as _eq
from keyword import iskeyword as _iskeyword
@ -39,11 +31,17 @@ from _weakref import proxy as _proxy
from itertools import repeat as _repeat, chain as _chain, starmap as _starmap
from reprlib import recursive_repr as _recursive_repr
from _collections import deque
MutableSequence.register(deque)
from _collections import defaultdict
try:
from _collections import deque
except ImportError:
pass
else:
MutableSequence.register(deque)
try:
from _collections import defaultdict
except ImportError:
pass
################################################################################
### OrderedDict
@ -1243,3 +1241,84 @@ class UserString(Sequence):
return self.__class__(self.data.translate(*args))
def upper(self): return self.__class__(self.data.upper())
def zfill(self, width): return self.__class__(self.data.zfill(width))
if __name__ == 'PYOBJ.COM':
import _collections
ABCMeta = 0
AsyncGenerator = 0
AsyncIterable = 0
AsyncIterator = 0
Awaitable = 0
ByteString = 0
Callable = 0
ChainMap = 0
Collection = 0
Container = 0
Coroutine = 0
Counter = 0
Generator = 0
Hashable = 0
ItemsView = 0
Iterable = 0
Iterator = 0
KeysView = 0
Mapping = 0
MappingView = 0
MutableMapping = 0
MutableSequence = 0
MutableSet = 0
OrderedDict = 0
Reversible = 0
Sequence = 0
Set = 0
Sized = 0
UserDict = 0
UserList = 0
UserString = 0
ValuesView = 0
_Link = 0
_OrderedDictItemsView = 0
_OrderedDictKeysView = 0
_OrderedDictValuesView = 0
_chain = 0
_check_methods = 0
_class_template = 0
_collections_abc = 0
_count_elements = 0
_eq = 0
_field_template = 0
_heapq = 0
_iskeyword = 0
_itemgetter = 0
_proxy = 0
_recursive_repr = 0
_repeat = 0
_repr_template = 0
_starmap = 0
_sys = 0
abstractmethod = 0
async_generator = 0
bytearray_iterator = 0
bytes_iterator = 0
coroutine = 0
defaultdict = 0
deque = 0
dict_itemiterator = 0
dict_items = 0
dict_keyiterator = 0
dict_keys = 0
dict_valueiterator = 0
dict_values = 0
generator = 0
list_iterator = 0
list_reverseiterator = 0
longrange_iterator = 0
mappingproxy = 0
namedtuple = 0
range_iterator = 0
set_iterator = 0
str_iterator = 0
sys = 0
tuple_iterator = 0
zip_iterator = 0

56
third_party/python/Lib/collections/abc.py vendored
View file

@ -1,27 +1,29 @@
from _collections_abc import (
Awaitable,
Coroutine,
AsyncIterable,
AsyncIterator,
AsyncGenerator,
Hashable,
Iterable,
Iterator,
Generator,
Reversible,
Sized,
Container,
Callable,
Collection,
Set,
MutableSet,
Mapping,
MutableMapping,
MappingView,
KeysView,
ItemsView,
ValuesView,
Sequence,
MutableSequence,
ByteString,
)
from _collections_abc import *
from _collections_abc import __all__
if __name__ == 'PYOBJ.COM':
AsyncGenerator = 0
AsyncIterable = 0
AsyncIterator = 0
Awaitable = 0
ByteString = 0
Callable = 0
Collection = 0
Container = 0
Coroutine = 0
Generator = 0
Hashable = 0
ItemsView = 0
Iterable = 0
Iterator = 0
KeysView = 0
Mapping = 0
MappingView = 0
MutableMapping = 0
MutableSequence = 0
MutableSet = 0
Reversible = 0
Sequence = 0
Set = 0
Sized = 0
ValuesView = 0

61
third_party/python/Lib/decimal.py vendored
View file

@ -1,10 +1,51 @@
# try:
from _decimal import BasicContext, Clamped, Context, ConversionSyntax, Decimal, DecimalException, DecimalTuple, DefaultContext, DivisionByZero, DivisionImpossible, DivisionUndefined, ExtendedContext, FloatOperation, HAVE_THREADS, Inexact, InvalidContext, InvalidOperation, MAX_EMAX, MAX_PREC, MIN_EMIN, MIN_ETINY, Overflow, ROUND_05UP, ROUND_CEILING, ROUND_DOWN, ROUND_FLOOR, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_HALF_UP, ROUND_UP, Rounded, Subnormal, Underflow, getcontext, localcontext, setcontext
from _decimal import __doc__
from _decimal import __version__
from _decimal import __libmpdec_version__
# except ImportError:
# from _pydecimal import *
# from _pydecimal import __doc__
# from _pydecimal import __version__
# from _pydecimal import __libmpdec_version__
try:
from _decimal import *
from _decimal import __doc__
from _decimal import __version__
from _decimal import __libmpdec_version__
except ImportError:
from _pydecimal import *
from _pydecimal import __doc__
from _pydecimal import __version__
from _pydecimal import __libmpdec_version__
if __name__ == 'PYOBJ.COM':
import _decimal
BasicContext = 0
Clamped = 0
Context = 0
ConversionSyntax = 0
Decimal = 0
DecimalException = 0
DecimalTuple = 0
DefaultContext = 0
DivisionByZero = 0
DivisionImpossible = 0
DivisionUndefined = 0
ExtendedContext = 0
FloatOperation = 0
HAVE_THREADS = 0
Inexact = 0
InvalidContext = 0
InvalidOperation = 0
MAX_EMAX = 0
MAX_PREC = 0
MIN_EMIN = 0
MIN_ETINY = 0
Overflow = 0
ROUND_05UP = 0
ROUND_CEILING = 0
ROUND_DOWN = 0
ROUND_FLOOR = 0
ROUND_HALF_DOWN = 0
ROUND_HALF_EVEN = 0
ROUND_HALF_UP = 0
ROUND_UP = 0
Rounded = 0
Subnormal = 0
Underflow = 0
__libmpdec_version__ = 0
__version__ = 0
getcontext = 0
localcontext = 0
setcontext = 0

48
third_party/python/Lib/dummy_threading.py vendored
View file

@ -77,26 +77,28 @@ finally:
del _dummy_thread
del sys_modules
Barrier = Barrier
BoundedSemaphore = BoundedSemaphore
BrokenBarrierError = BrokenBarrierError
Condition = Condition
Event = Event
Lock = Lock
RLock = RLock
Semaphore = Semaphore
TIMEOUT_MAX = TIMEOUT_MAX
Thread = Thread
ThreadError = ThreadError
Timer = Timer
WeakSet = WeakSet
activeCount = activeCount
active_count = active_count
currentThread = currentThread
current_thread = current_thread
get_ident = get_ident
local = local
main_thread = main_thread
setprofile = setprofile
settrace = settrace
stack_size = stack_size
if __name__ == 'PYOBJ.COM':
Barrier = 0
BoundedSemaphore = 0
BrokenBarrierError = 0
Condition = 0
Event = 0
Lock = 0
RLock = 0
Semaphore = 0
TIMEOUT_MAX = 0
Thread = 0
ThreadError = 0
Timer = 0
WeakSet = 0
activeCount = 0
active_count = 0
currentThread = 0
current_thread = 0
enumerate = 0
get_ident = 0
local = 0
main_thread = 0
setprofile = 0
settrace = 0
stack_size = 0

1
third_party/python/Lib/email/base64mime.py vendored
View file

@ -36,6 +36,7 @@ __all__ = [
from base64 import b64encode
from binascii import b2a_base64, a2b_base64
from encodings import raw_unicode_escape
CRLF = '\r\n'
NL = '\n'

23
third_party/python/Lib/email/charset.py vendored
View file

@ -17,6 +17,29 @@ import email.quoprimime
from email import errors
from email.encoders import encode_7or8bit
from encodings import (
base64_codec,
quopri_codec,
iso8859_1,
iso8859_2,
iso8859_3,
iso8859_4,
iso8859_9,
iso8859_10,
iso8859_13,
iso8859_14,
iso8859_15,
iso8859_16,
iso8859_10,
cp1252,
big5,
gb2312,
euc_jp,
shift_jis,
iso2022_jp,
koi8_r,
utf_8,
)
# Flags for types of header encodings

8
third_party/python/Lib/email/message.py vendored
View file

@ -11,13 +11,18 @@ import uu
import quopri
from io import BytesIO, StringIO
from encodings import (
base64_codec,
quopri_codec,
raw_unicode_escape,
)
# Intrapackage imports
from email import utils
from email import errors
from email._policybase import Policy, compat32
from email import charset as _charset
from email._encoded_words import decode_b
from email.iterators import walk
Charset = _charset.Charset
SEMISPACE = '; '
@ -940,6 +945,7 @@ class Message:
return c_d
# I.e. def walk(self): ...
from email.iterators import walk
class MIMEPart(Message):

4
third_party/python/Lib/functools.py vendored
View file

@ -814,3 +814,7 @@ def singledispatch(func):
wrapper._clear_cache = dispatch_cache.clear
update_wrapper(wrapper, func)
return wrapper
if __name__ == 'PYOBJ.COM':
import _functools

71
third_party/python/Lib/hashlib.py vendored
View file

@ -11,7 +11,10 @@ new(name, data=b'', **kwargs) - returns a new hash object implementing the
Named constructor functions are also available, these are faster
than using new(name):
md5(), sha1(), sha224(), sha256(), sha384(), sha512(), and blake2b256().
md5(), sha1(), sha224(), sha256(), sha384(), sha512(), sha3_224(),
sha3_256(), sha3_384(), sha3_512(), shake_128(), shake_256(), and
finally blake2b256() which is an Actually Portable Python feature
courtesy of the BoringSSL project at Google, and we thank ARM too
More algorithms may be available on your platform but the above are guaranteed
to exist. See the algorithms_guaranteed and algorithms_available attributes
@ -52,10 +55,22 @@ More condensed:
"""
# import _hashlib as _prevent_recursive_loading
# del _prevent_recursive_loading
# if __name__ == 'PYOBJ.COM': import _sha3, _hashlib # static-only
if __name__ == 'PYOBJ.COM':
import _md5
import _sha1
import _sha256
import _sha512
# This tuple and __get_builtin_constructor() must be modified if a new
# always available algorithm is added.
__always_supported = ('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512',
'blake2b256')
# 'sha3_224', 'sha3_256', 'sha3_384',
# 'sha3_512', 'shake_128', 'shake_256'
)
algorithms_guaranteed = set(__always_supported)
algorithms_available = set(__always_supported)
@ -70,12 +85,23 @@ def __get_builtin_constructor(name):
constructor = cache.get(name)
if constructor is not None:
return constructor
if name in ('MD5', 'md5'):
import _md5
cache['MD5'] = cache['md5'] = _md5.md5
elif name in {'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512',
'shake_128', 'shake_256'}:
try:
try:
if name in ('SHA1', 'sha1'):
import _sha1
cache['SHA1'] = cache['sha1'] = _sha1.sha1
elif name in ('MD5', 'md5'):
import _md5
cache['MD5'] = cache['md5'] = _md5.md5
elif name in ('SHA256', 'sha256', 'SHA224', 'sha224'):
import _sha256
cache['SHA224'] = cache['sha224'] = _sha256.sha224
cache['SHA256'] = cache['sha256'] = _sha256.sha256
elif name in ('SHA512', 'sha512', 'SHA384', 'sha384'):
import _sha512
cache['SHA384'] = cache['sha384'] = _sha512.sha384
cache['SHA512'] = cache['sha512'] = _sha512.sha512
elif name in {'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512',
'shake_128', 'shake_256'}:
import _sha3
cache['sha3_224'] = _sha3.sha3_224
cache['sha3_256'] = _sha3.sha3_256
@ -83,11 +109,13 @@ def __get_builtin_constructor(name):
cache['sha3_512'] = _sha3.sha3_512
cache['shake_128'] = _sha3.shake_128
cache['shake_256'] = _sha3.shake_256
except ImportError:
raise ValueError('unsupported hash type ' + name)
except ImportError:
pass # no extension module, this hash is unsupported.
constructor = cache.get(name)
if constructor is not None:
return constructor
raise ValueError('unsupported hash type ' + name)
@ -125,11 +153,15 @@ def __hash_new(name, data=b'', **kwargs):
return __get_builtin_constructor(name)(data)
import _hashlib
new = __hash_new
__get_hash = __get_mbedtls_constructor
algorithms_available = algorithms_available.union(
_hashlib.mbedtls_md_meth_names)
try:
import _hashlib
new = __hash_new
__get_hash = __get_mbedtls_constructor
algorithms_available = algorithms_available.union(
_hashlib.mbedtls_md_meth_names)
except ImportError as e:
new = __py_new
__get_hash = __get_builtin_constructor
try:
# Mbedtls's PKCS5_PBKDF2_HMAC requires Mbedtls 1.0+ with HMAC and SHA
@ -201,13 +233,20 @@ try:
except ImportError:
pass
md5 = __get_hash('md5')
sha1 = __get_hash('sha1')
sha224 = __get_hash('sha224')
sha256 = __get_hash('sha256')
sha384 = __get_hash('sha384')
sha512 = __get_hash('sha512')
blake2b256 = __get_hash('blake2b256')
# sha3_224 = __get_hash('sha3_224')
# sha3_256 = __get_hash('sha3_256')
# sha3_384 = __get_hash('sha3_384')
# sha3_512 = __get_hash('sha3_512')
# shake_128 = __get_hash('shake_128')
# shake_256 = __get_hash('shake_256')
# Cleanup locals()
del __always_supported, __get_hash

10
third_party/python/Lib/hello.py vendored
View file

@ -1 +1,9 @@
print("hello world")
import hashlib
# import sys
# import urllib.request
# with urllib.request.urlopen("http://justine.lol") as resp:
# sys.stdout.buffer.write(resp.read())
# print("hello world")

2
third_party/python/Lib/json/decoder.py vendored
View file

@ -7,6 +7,8 @@ try:
from _json import scanstring as c_scanstring
except ImportError:
c_scanstring = None
if __name__ == 'PYOBJ.COM':
import _json
__all__ = ['JSONDecoder', 'JSONDecodeError']

2
third_party/python/Lib/json/encoder.py vendored
View file

@ -14,6 +14,8 @@ try:
from _json import make_encoder as c_make_encoder
except ImportError:
c_make_encoder = None
if __name__ == 'PYOBJ.COM':
import _json
ESCAPE = re.compile(r'[\x00-\x1f\\"\b\f\n\r\t]')
ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])')

2
third_party/python/Lib/json/scanner.py vendored
View file

@ -5,6 +5,8 @@ try:
from _json import make_scanner as c_make_scanner
except ImportError:
c_make_scanner = None
if __name__ == 'PYOBJ.COM':
import _json
__all__ = ['make_scanner']

2
third_party/python/Lib/launchpy.py vendored
View file

@ -7,7 +7,7 @@ def run_module_as_main(mod_name):
code = loader.get_code(mod_name)
globs = sys.modules["__main__"].__dict__
globs["__name__"] = "__main__"
globs["__file__"] = path
globs["__file__"] = path[:-1]
globs["__package__"] = None
globs["__loader__"] = loader
globs["__spec__"] = None

0
third_party/python/Lib/test/mime.types → third_party/python/Lib/mime.types vendored
View file

1
third_party/python/Lib/mimetypes.py vendored
View file

@ -40,6 +40,7 @@ __all__ = [
]
knownfiles = [
"/zip/.python/mime.types",
"/etc/mime.types",
"/etc/httpd/mime.types", # Mac OS X
"/etc/httpd/conf/mime.types", # Apache

3
third_party/python/Lib/operator.py vendored
View file

@ -415,6 +415,9 @@ except ImportError:
else:
from _operator import __doc__
if __name__ == 'PYOBJ.COM':
import _operator
# All of these "__func__ = func" assignments have to happen after importing
# from _operator to make sure they're set to the right function
__lt__ = lt

634
third_party/python/Lib/os.py vendored
View file

@ -43,235 +43,20 @@ def _get_exports_list(module):
except AttributeError:
return [n for n in dir(module) if n[0] != '_']
# Any new dependencies of the os module and/or changes in path separator
# requires updating importlib as well.
name = 'posix'
linesep = '\n'
from posix import *
try:
from posix import _exit
__all__.append('_exit')
except ImportError:
pass
import posixpath as path
try:
from posix import _have_functions
except ImportError:
pass
import posix
CLD_CONTINUED = posix.CLD_CONTINUED
CLD_DUMPED = posix.CLD_DUMPED
CLD_EXITED = posix.CLD_EXITED
CLD_TRAPPED = posix.CLD_TRAPPED
DirEntry = posix.DirEntry
EX_CANTCREAT = posix.EX_CANTCREAT
EX_CONFIG = posix.EX_CONFIG
EX_DATAERR = posix.EX_DATAERR
EX_IOERR = posix.EX_IOERR
EX_NOHOST = posix.EX_NOHOST
EX_NOINPUT = posix.EX_NOINPUT
EX_NOPERM = posix.EX_NOPERM
EX_NOUSER = posix.EX_NOUSER
EX_OK = posix.EX_OK
EX_OSERR = posix.EX_OSERR
EX_OSFILE = posix.EX_OSFILE
EX_PROTOCOL = posix.EX_PROTOCOL
EX_SOFTWARE = posix.EX_SOFTWARE
EX_TEMPFAIL = posix.EX_TEMPFAIL
EX_UNAVAILABLE = posix.EX_UNAVAILABLE
EX_USAGE = posix.EX_USAGE
F_LOCK = posix.F_LOCK
F_OK = posix.F_OK
F_TEST = posix.F_TEST
F_TLOCK = posix.F_TLOCK
F_ULOCK = posix.F_ULOCK
GRND_NONBLOCK = posix.GRND_NONBLOCK
GRND_NORDRND = posix.GRND_NORDRND
GRND_NOSYSTEM = posix.GRND_NOSYSTEM
GRND_RANDOM = posix.GRND_RANDOM
O_ACCMODE = posix.O_ACCMODE
O_APPEND = posix.O_APPEND
O_ASYNC = posix.O_ASYNC
O_CLOEXEC = posix.O_CLOEXEC
O_CREAT = posix.O_CREAT
O_DIRECT = posix.O_DIRECT
O_DIRECTORY = posix.O_DIRECTORY
O_DSYNC = posix.O_DSYNC
O_EXCL = posix.O_EXCL
O_LARGEFILE = posix.O_LARGEFILE
O_NDELAY = posix.O_NDELAY
O_NOATIME = posix.O_NOATIME
O_NOCTTY = posix.O_NOCTTY
O_NOFOLLOW = posix.O_NOFOLLOW
O_NONBLOCK = posix.O_NONBLOCK
O_PATH = posix.O_PATH
O_RDONLY = posix.O_RDONLY
O_RDWR = posix.O_RDWR
O_RSYNC = posix.O_RSYNC
O_SYNC = posix.O_SYNC
O_TMPFILE = posix.O_TMPFILE
O_TRUNC = posix.O_TRUNC
O_WRONLY = posix.O_WRONLY
POSIX_FADV_DONTNEED = posix.POSIX_FADV_DONTNEED
POSIX_FADV_NOREUSE = posix.POSIX_FADV_NOREUSE
POSIX_FADV_NORMAL = posix.POSIX_FADV_NORMAL
POSIX_FADV_RANDOM = posix.POSIX_FADV_RANDOM
POSIX_FADV_SEQUENTIAL = posix.POSIX_FADV_SEQUENTIAL
POSIX_FADV_WILLNEED = posix.POSIX_FADV_WILLNEED
PRIO_PGRP = posix.PRIO_PGRP
PRIO_PROCESS = posix.PRIO_PROCESS
PRIO_USER = posix.PRIO_USER
RTLD_GLOBAL = posix.RTLD_GLOBAL
RTLD_LAZY = posix.RTLD_LAZY
RTLD_LOCAL = posix.RTLD_LOCAL
RTLD_NOW = posix.RTLD_NOW
R_OK = posix.R_OK
SCHED_BATCH = posix.SCHED_BATCH
SCHED_FIFO = posix.SCHED_FIFO
SCHED_IDLE = posix.SCHED_IDLE
SCHED_OTHER = posix.SCHED_OTHER
SCHED_RESET_ON_FORK = posix.SCHED_RESET_ON_FORK
SCHED_RR = posix.SCHED_RR
ST_APPEND = posix.ST_APPEND
ST_MANDLOCK = posix.ST_MANDLOCK
ST_NOATIME = posix.ST_NOATIME
ST_NODEV = posix.ST_NODEV
ST_NODIRATIME = posix.ST_NODIRATIME
ST_NOEXEC = posix.ST_NOEXEC
ST_NOSUID = posix.ST_NOSUID
ST_RDONLY = posix.ST_RDONLY
ST_RELATIME = posix.ST_RELATIME
ST_SYNCHRONOUS = posix.ST_SYNCHRONOUS
ST_WRITE = posix.ST_WRITE
WCONTINUED = posix.WCONTINUED
WCOREDUMP = posix.WCOREDUMP
WEXITED = posix.WEXITED
WEXITSTATUS = posix.WEXITSTATUS
WIFCONTINUED = posix.WIFCONTINUED
WIFEXITED = posix.WIFEXITED
WIFSIGNALED = posix.WIFSIGNALED
WIFSTOPPED = posix.WIFSTOPPED
WNOHANG = posix.WNOHANG
WNOWAIT = posix.WNOWAIT
WSTOPPED = posix.WSTOPPED
WSTOPSIG = posix.WSTOPSIG
WTERMSIG = posix.WTERMSIG
WUNTRACED = posix.WUNTRACED
W_OK = posix.W_OK
X_OK = posix.X_OK
_exit = posix._exit
_have_functions = posix._have_functions
abort = posix.abort
access = posix.access
chdir = posix.chdir
chmod = posix.chmod
chown = posix.chown
chroot = posix.chroot
close = posix.close
closerange = posix.closerange
cpu_count = posix.cpu_count
device_encoding = posix.device_encoding
dup = posix.dup
dup2 = posix.dup2
environ = posix.environ
error = posix.error
execv = posix.execv
execve = posix.execve
fchdir = posix.fchdir
fchmod = posix.fchmod
fchown = posix.fchown
fdatasync = posix.fdatasync
fork = posix.fork
fpathconf = posix.fpathconf
fspath = posix.fspath
fstat = posix.fstat
fsync = posix.fsync
ftruncate = posix.ftruncate
get_blocking = posix.get_blocking
get_inheritable = posix.get_inheritable
get_terminal_size = posix.get_terminal_size
getcwd = posix.getcwd
getcwdb = posix.getcwdb
getgrouplist = posix.getgrouplist
getgroups = posix.getgroups
getlogin = posix.getlogin
getpgid = posix.getpgid
getpgrp = posix.getpgrp
getpid = posix.getpid
getpriority = posix.getpriority
getsid = posix.getsid
getuid = posix.getuid
initgroups = posix.initgroups
isatty = posix.isatty
kill = posix.kill
killpg = posix.killpg
lchown = posix.lchown
link = posix.link
listdir = posix.listdir
lseek = posix.lseek
lstat = posix.lstat
major = posix.major
makedev = posix.makedev
minor = posix.minor
mkdir = posix.mkdir
mkfifo = posix.mkfifo
mknod = posix.mknod
nice = posix.nice
open = posix.open
openpty = posix.openpty
pathconf = posix.pathconf
pathconf_names = posix.pathconf_names
pipe = posix.pipe
pipe2 = posix.pipe2
posix_fadvise = posix.posix_fadvise
pread = posix.pread
putenv = posix.putenv
pwrite = posix.pwrite
read = posix.read
readlink = posix.readlink
readv = posix.readv
remove = posix.remove
rename = posix.rename
replace = posix.replace
rmdir = posix.rmdir
scandir = posix.scandir
sched_yield = posix.sched_yield
sendfile = posix.sendfile
set_blocking = posix.set_blocking
set_inheritable = posix.set_inheritable
setegid = posix.setegid
seteuid = posix.seteuid
setgid = posix.setgid
setpgid = posix.setpgid
setpriority = posix.setpriority
setregid = posix.setregid
setresgid = posix.setresgid
setresuid = posix.setresuid
setreuid = posix.setreuid
setsid = posix.setsid
setuid = posix.setuid
stat = posix.stat
stat_float_times = posix.stat_float_times
stat_result = posix.stat_result
statvfs_result = posix.statvfs_result
strerror = posix.strerror
symlink = posix.symlink
sync = posix.sync
sysconf = posix.sysconf
sysconf_names = posix.sysconf_names
system = posix.system
tcgetpgrp = posix.tcgetpgrp
tcsetpgrp = posix.tcsetpgrp
terminal_size = posix.terminal_size
times = posix.times
times_result = posix.times_result
truncate = posix.truncate
umask = posix.umask
uname = posix.uname
uname_result = posix.uname_result
unlink = posix.unlink
unsetenv = posix.unsetenv
urandom = posix.urandom
utime = posix.utime
wait = posix.wait
wait3 = posix.wait3
wait4 = posix.wait4
waitpid = posix.waitpid
write = posix.write
writev = posix.writev
__all__.extend(_get_exports_list(posix))
del posix
@ -282,90 +67,93 @@ from os.path import (curdir, pardir, sep, pathsep, defpath, extsep, altsep,
del _names
_globals = globals()
def _add(str, fn):
if (fn in _globals) and (str in _have_functions):
_set.add(_globals[fn])
if _exists("_have_functions"):
_globals = globals()
def _add(str, fn):
if (fn in _globals) and (str in _have_functions):
_set.add(_globals[fn])
_set = set()
_add("HAVE_FACCESSAT", "access")
_add("HAVE_FCHMODAT", "chmod")
_add("HAVE_FCHOWNAT", "chown")
_add("HAVE_FSTATAT", "stat")
_add("HAVE_FUTIMESAT", "utime")
_add("HAVE_LINKAT", "link")
_add("HAVE_MKDIRAT", "mkdir")
_add("HAVE_MKFIFOAT", "mkfifo")
_add("HAVE_MKNODAT", "mknod")
_add("HAVE_OPENAT", "open")
_add("HAVE_READLINKAT", "readlink")
_add("HAVE_RENAMEAT", "rename")
_add("HAVE_SYMLINKAT", "symlink")
_add("HAVE_UNLINKAT", "unlink")
_add("HAVE_UNLINKAT", "rmdir")
_add("HAVE_UTIMENSAT", "utime")
supports_dir_fd = _set
_set = set()
_add("HAVE_FACCESSAT", "access")
_add("HAVE_FCHMODAT", "chmod")
_add("HAVE_FCHOWNAT", "chown")
_add("HAVE_FSTATAT", "stat")
_add("HAVE_FUTIMESAT", "utime")
_add("HAVE_LINKAT", "link")
_add("HAVE_MKDIRAT", "mkdir")
_add("HAVE_MKFIFOAT", "mkfifo")
_add("HAVE_MKNODAT", "mknod")
_add("HAVE_OPENAT", "open")
_add("HAVE_READLINKAT", "readlink")
_add("HAVE_RENAMEAT", "rename")
_add("HAVE_SYMLINKAT", "symlink")
_add("HAVE_UNLINKAT", "unlink")
_add("HAVE_UNLINKAT", "rmdir")
_add("HAVE_UTIMENSAT", "utime")
supports_dir_fd = _set
_set = set()
_add("HAVE_FACCESSAT", "access")
supports_effective_ids = _set
_set = set()
_add("HAVE_FACCESSAT", "access")
supports_effective_ids = _set
_set = set()
_add("HAVE_FCHDIR", "chdir")
_add("HAVE_FCHMOD", "chmod")
_add("HAVE_FCHOWN", "chown")
_add("HAVE_FDOPENDIR", "listdir")
_add("HAVE_FEXECVE", "execve")
_set.add(stat) # fstat always works
_add("HAVE_FTRUNCATE", "truncate")
_add("HAVE_FUTIMENS", "utime")
_add("HAVE_FUTIMES", "utime")
_add("HAVE_FPATHCONF", "pathconf")
if _exists("statvfs") and _exists("fstatvfs"): # mac os x10.3
_add("HAVE_FSTATVFS", "statvfs")
supports_fd = _set
_set = set()
_add("HAVE_FCHDIR", "chdir")
_add("HAVE_FCHMOD", "chmod")
if _exists("chown"):
_add("HAVE_FCHOWN", "chown")
_add("HAVE_FDOPENDIR", "listdir")
_add("HAVE_FEXECVE", "execve")
_set.add(stat) # fstat always works
_add("HAVE_FTRUNCATE", "truncate")
_add("HAVE_FUTIMENS", "utime")
_add("HAVE_FUTIMES", "utime")
_add("HAVE_FPATHCONF", "pathconf")
if _exists("statvfs") and _exists("fstatvfs"): # mac os x10.3
_add("HAVE_FSTATVFS", "statvfs")
supports_fd = _set
_set = set()
_add("HAVE_FACCESSAT", "access")
# Some platforms don't support lchmod(). Often the function exists
# anyway, as a stub that always returns ENOSUP or perhaps EOPNOTSUPP.
# (No, I don't know why that's a good design.) ./configure will detect
# this and reject it--so HAVE_LCHMOD still won't be defined on such
# platforms. This is Very Helpful.
#
# However, sometimes platforms without a working lchmod() *do* have
# fchmodat(). (Examples: Linux kernel 3.2 with glibc 2.15,
# OpenIndiana 3.x.) And fchmodat() has a flag that theoretically makes
# it behave like lchmod(). So in theory it would be a suitable
# replacement for lchmod(). But when lchmod() doesn't work, fchmodat()'s
# flag doesn't work *either*. Sadly ./configure isn't sophisticated
# enough to detect this condition--it only determines whether or not
# fchmodat() minimally works.
#
# Therefore we simply ignore fchmodat() when deciding whether or not
# os.chmod supports follow_symlinks. Just checking lchmod() is
# sufficient. After all--if you have a working fchmodat(), your
# lchmod() almost certainly works too.
#
# _add("HAVE_FCHMODAT", "chmod")
_add("HAVE_FCHOWNAT", "chown")
_add("HAVE_FSTATAT", "stat")
_add("HAVE_LCHFLAGS", "chflags")
_add("HAVE_LCHMOD", "chmod")
if _exists("lchown"): # mac os x10.3
_add("HAVE_LCHOWN", "chown")
_add("HAVE_LINKAT", "link")
_add("HAVE_LUTIMES", "utime")
_add("HAVE_LSTAT", "stat")
_add("HAVE_FSTATAT", "stat")
_add("HAVE_UTIMENSAT", "utime")
_add("MS_WINDOWS", "stat")
supports_follow_symlinks = _set
_set = set()
_add("HAVE_FACCESSAT", "access")
# Some platforms don't support lchmod(). Often the function exists
# anyway, as a stub that always returns ENOSUP or perhaps EOPNOTSUPP.
# (No, I don't know why that's a good design.) ./configure will detect
# this and reject it--so HAVE_LCHMOD still won't be defined on such
# platforms. This is Very Helpful.
#
# However, sometimes platforms without a working lchmod() *do* have
# fchmodat(). (Examples: Linux kernel 3.2 with glibc 2.15,
# OpenIndiana 3.x.) And fchmodat() has a flag that theoretically makes
# it behave like lchmod(). So in theory it would be a suitable
# replacement for lchmod(). But when lchmod() doesn't work, fchmodat()'s
# flag doesn't work *either*. Sadly ./configure isn't sophisticated
# enough to detect this condition--it only determines whether or not
# fchmodat() minimally works.
#
# Therefore we simply ignore fchmodat() when deciding whether or not
# os.chmod supports follow_symlinks. Just checking lchmod() is
# sufficient. After all--if you have a working fchmodat(), your
# lchmod() almost certainly works too.
#
# _add("HAVE_FCHMODAT", "chmod")
if _exists("chown"):
_add("HAVE_FCHOWNAT", "chown")
_add("HAVE_FSTATAT", "stat")
_add("HAVE_LCHFLAGS", "chflags")
_add("HAVE_LCHMOD", "chmod")
if _exists("lchown"): # mac os x10.3
_add("HAVE_LCHOWN", "chown")
_add("HAVE_LINKAT", "link")
_add("HAVE_LUTIMES", "utime")
_add("HAVE_LSTAT", "stat")
_add("HAVE_FSTATAT", "stat")
_add("HAVE_UTIMENSAT", "utime")
_add("MS_WINDOWS", "stat")
supports_follow_symlinks = _set
del _set
del _have_functions
del _globals
del _add
del _set
del _have_functions
del _globals
del _add
# Python uses fixed values for the SEEK_ constants; they are mapped
@ -1158,10 +946,7 @@ def popen(cmd, mode="r", buffering=-1):
raise ValueError("invalid mode %r" % mode)
if buffering == 0 or buffering is None:
raise ValueError("popen() does not support unbuffered streams")
try:
import subprocess, io
except ImportError:
raise ImportError('please use subprocess module')
import subprocess, io
if mode == "r":
proc = subprocess.Popen(cmd,
shell=True,
@ -1256,3 +1041,236 @@ class PathLike(abc.ABC):
@classmethod
def __subclasshook__(cls, subclass):
return hasattr(subclass, '__fspath__')
if __name__ == 'PYOBJ.COM':
CLD_CONTINUED = 0
CLD_DUMPED = 0
CLD_EXITED = 0
CLD_TRAPPED = 0
DirEntry = 0
EX_CANTCREAT = 0
EX_CONFIG = 0
EX_DATAERR = 0
EX_IOERR = 0
EX_NOHOST = 0
EX_NOINPUT = 0
EX_NOPERM = 0
EX_NOUSER = 0
EX_OK = 0
EX_OSERR = 0
EX_OSFILE = 0
EX_PROTOCOL = 0
EX_SOFTWARE = 0
EX_TEMPFAIL = 0
EX_UNAVAILABLE = 0
EX_USAGE = 0
F_LOCK = 0
F_OK = 0
F_TEST = 0
F_TLOCK = 0
F_ULOCK = 0
GRND_NONBLOCK = 0
GRND_NORDRND = 0
GRND_NOSYSTEM = 0
GRND_RANDOM = 0
HAVE_FACCESSAT = 0
HAVE_FCHMODAT = 0
HAVE_FCHOWNAT = 0
HAVE_FSTATAT = 0
HAVE_FSTATAT = 0
HAVE_LCHFLAGS = 0
HAVE_LCHMOD = 0
HAVE_LCHOWN = 0
HAVE_LINKAT = 0
HAVE_LSTAT = 0
HAVE_LUTIMES = 0
HAVE_UTIMENSAT = 0
MS_WINDOWS = 0
O_ACCMODE = 0
O_APPEND = 0
O_ASYNC = 0
O_CLOEXEC = 0
O_CREAT = 0
O_DIRECT = 0
O_DIRECTORY = 0
O_DSYNC = 0
O_EXCL = 0
O_EXEC = 0
O_EXLOCK = 0
O_LARGEFILE = 0
O_NDELAY = 0
O_NOATIME = 0
O_NOCTTY = 0
O_NOFOLLOW = 0
O_NOFOLLOW = 0
O_NOFOLLOW_ANY = 0
O_NONBLOCK = 0
O_PATH = 0
O_RANDOM = 0
O_RDONLY = 0
O_RDWR = 0
O_RSYNC = 0
O_SEQUENTIAL = 0
O_SHLOCK = 0
O_SYNC = 0
O_TMPFILE = 0
O_TRUNC = 0
O_TTY_INIT = 0
O_WRONLY = 0
POSIX_FADV_DONTNEED = 0
POSIX_FADV_NOREUSE = 0
POSIX_FADV_NORMAL = 0
POSIX_FADV_RANDOM = 0
POSIX_FADV_SEQUENTIAL = 0
POSIX_FADV_WILLNEED = 0
PRIO_PGRP = 0
PRIO_PROCESS = 0
PRIO_USER = 0
RTLD_GLOBAL = 0
RTLD_LAZY = 0
RTLD_LOCAL = 0
RTLD_NOW = 0
R_OK = 0
SCHED_BATCH = 0
SCHED_FIFO = 0
SCHED_IDLE = 0
SCHED_OTHER = 0
SCHED_RESET_ON_FORK = 0
SCHED_RR = 0
WCONTINUED = 0
WCOREDUMP = 0
WEXITED = 0
WEXITSTATUS = 0
WIFCONTINUED = 0
WIFEXITED = 0
WIFSIGNALED = 0
WIFSTOPPED = 0
WNOHANG = 0
WNOWAIT = 0
WSTOPPED = 0
WSTOPSIG = 0
WTERMSIG = 0
WUNTRACED = 0
W_OK = 0
X_OK = 0
_exit = 0
_have_functions = 0
abort = 0
access = 0
chdir = 0
chmod = 0
chown = 0
chroot = 0
close = 0
closerange = 0
cpu_count = 0
device_encoding = 0
dup = 0
dup2 = 0
environ = 0
error = 0
execv = 0
execve = 0
fchdir = 0
fchmod = 0
fchown = 0
fdatasync = 0
fork = 0
fpathconf = 0
fspath = 0
fstat = 0
fsync = 0
ftruncate = 0
get_blocking = 0
get_inheritable = 0
get_terminal_size = 0
getcwd = 0
getcwdb = 0
getgrouplist = 0
getgroups = 0
getlogin = 0
getpgid = 0
getpgrp = 0
getpid = 0
getpriority = 0
getsid = 0
getuid = 0
initgroups = 0
isatty = 0
kill = 0
killpg = 0
lchown = 0
link = 0
listdir = 0
lseek = 0
lstat = 0
major = 0
makedev = 0
minor = 0
mkdir = 0
mkfifo = 0
mknod = 0
nice = 0
open = 0
openpty = 0
pathconf = 0
pathconf_names = 0
pipe = 0
pipe2 = 0
posix_fadvise = 0
pread = 0
putenv = 0
pwrite = 0
read = 0
readlink = 0
readv = 0
remove = 0
rename = 0
replace = 0
rmdir = 0
scandir = 0
sched_yield = 0
sendfile = 0
set_blocking = 0
set_inheritable = 0
setegid = 0
seteuid = 0
setgid = 0
setpgid = 0
setpriority = 0
setregid = 0
setresgid = 0
setresuid = 0
setreuid = 0
setsid = 0
setuid = 0
stat = 0
stat_float_times = 0
stat_result = 0
statvfs_result = 0
strerror = 0
symlink = 0
sync = 0
sysconf = 0
sysconf_names = 0
system = 0
tcgetpgrp = 0
tcsetpgrp = 0
terminal_size = 0
times = 0
times_result = 0
truncate = 0
umask = 0
uname = 0
uname_result = 0
unlink = 0
unsetenv = 0
urandom = 0
utime = 0
wait = 0
wait3 = 0
wait4 = 0
waitpid = 0
write = 0
writev = 0

1
third_party/python/Lib/pickle.py vendored
View file

@ -28,6 +28,7 @@ from copyreg import dispatch_table
from copyreg import _extension_registry, _inverted_registry, _extension_cache
from itertools import islice
from functools import partial
from encodings import raw_unicode_escape
import sys
from sys import maxsize
from struct import pack, unpack

2
third_party/python/Lib/quopri.py vendored
View file

@ -11,6 +11,8 @@ MAXLINESIZE = 76
HEX = b'0123456789ABCDEF'
EMPTYSTRING = b''
from encodings import quopri_codec, aliases
try:
from binascii import a2b_qp, b2a_qp
except ImportError:

47
third_party/python/Lib/signal.py vendored
View file

@ -77,3 +77,50 @@ if 'sigwait' in _globals:
sigwait.__doc__ = _signal.sigwait
del _globals, _wraps
if __name__ == 'PYOBJ.COM':
ITIMER_PROF = 0
ITIMER_REAL = 0
ITIMER_VIRTUAL = 0
NSIG = 0
SIGABRT = 0
SIGALRM = 0
SIGBUS = 0
SIGCHLD = 0
SIGCONT = 0
SIGEMT = 0
SIGFPE = 0
SIGHUP = 0
SIGILL = 0
SIGINFO = 0
SIGINT = 0
SIGIO = 0
SIGIOT = 0
SIGKILL = 0
SIGPIPE = 0
SIGPOLL = 0
SIGPROF = 0
SIGPWR = 0
SIGQUIT = 0
SIGRTMAX = 0
SIGRTMIN = 0
SIGSEGV = 0
SIGSTOP = 0
SIGSYS = 0
SIGTERM = 0
SIGTRAP = 0
SIGTSTP = 0
SIGTTIN = 0
SIGTTOU = 0
SIGURG = 0
SIGUSR1 = 0
SIGUSR2 = 0
SIGVTALRM = 0
SIGWINCH = 0
SIGXCPU = 0
SIGXFSZ = 0
SIG_BLOCK = 0
SIG_DFL = 0
SIG_IGN = 0
SIG_SETMASK = 0
SIG_UNBLOCK = 0

215
third_party/python/Lib/socket.py vendored
View file

@ -47,7 +47,7 @@ the setsockopt() and getsockopt() methods.
"""
import _socket
from _socket import AF_APPLETALK, AF_ASH, AF_ATMPVC, AF_ATMSVC, AF_AX25, AF_BRIDGE, AF_CAN, AF_ECONET, AF_INET, AF_INET6, AF_IPX, AF_IRDA, AF_KEY, AF_LLC, AF_NETBEUI, AF_NETROM, AF_PACKET, AF_PPPOX, AF_RDS, AF_ROSE, AF_ROUTE, AF_SECURITY, AF_SNA, AF_UNIX, AF_UNSPEC, AF_X25, AI_ADDRCONFIG, AI_ALL, AI_CANONNAME, AI_NUMERICHOST, AI_NUMERICSERV, AI_PASSIVE, AI_V4MAPPED, CAPI, EAI_ADDRFAMILY, EAI_AGAIN, EAI_BADFLAGS, EAI_FAIL, EAI_FAMILY, EAI_MEMORY, EAI_NODATA, EAI_NONAME, EAI_OVERFLOW, EAI_SERVICE, EAI_SOCKTYPE, EAI_SYSTEM, INADDR_ALLHOSTS_GROUP, INADDR_ANY, INADDR_BROADCAST, INADDR_LOOPBACK, INADDR_MAX_LOCAL_GROUP, INADDR_NONE, INADDR_UNSPEC_GROUP, IPPORT_RESERVED, IPPORT_USERRESERVED, IPPROTO_AH, IPPROTO_DSTOPTS, IPPROTO_EGP, IPPROTO_ESP, IPPROTO_FRAGMENT, IPPROTO_GRE, IPPROTO_HOPOPTS, IPPROTO_ICMP, IPPROTO_ICMPV6, IPPROTO_IDP, IPPROTO_IGMP, IPPROTO_IP, IPPROTO_IPIP, IPPROTO_IPV6, IPPROTO_MAX, IPPROTO_NONE, IPPROTO_PIM, IPPROTO_PUP, IPPROTO_RAW, IPPROTO_ROUTING, IPPROTO_RSVP, IPPROTO_SCTP, IPPROTO_TCP, IPPROTO_TP, IPPROTO_UDP, IP_ADD_MEMBERSHIP, IP_DEFAULT_MULTICAST_LOOP, IP_DEFAULT_MULTICAST_TTL, IP_DROP_MEMBERSHIP, IP_HDRINCL, IP_MAX_MEMBERSHIPS, IP_MULTICAST_IF, IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_OPTIONS, IP_RECVOPTS, IP_RECVRETOPTS, IP_RETOPTS, IP_TOS, IP_TRANSPARENT, IP_TTL, MSG_CMSG_CLOEXEC, MSG_CONFIRM, MSG_CTRUNC, MSG_DONTROUTE, MSG_DONTWAIT, MSG_EOF, MSG_EOR, MSG_ERRQUEUE, MSG_FASTOPEN, MSG_MORE, MSG_NOSIGNAL, MSG_NOTIFICATION, MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL, NI_DGRAM, NI_MAXHOST, NI_MAXSERV, NI_NAMEREQD, NI_NOFQDN, NI_NUMERICHOST, NI_NUMERICSERV, PF_CAN, PF_PACKET, PF_RDS, SHUT_RD, SHUT_RDWR, SHUT_WR, SOCK_CLOEXEC, SOCK_DGRAM, SOCK_NONBLOCK, SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET, SOCK_STREAM, SOL_IP, SOL_RDS, SOL_SOCKET, SOL_TCP, SOL_UDP, SOMAXCONN, SO_ACCEPTCONN, SO_BINDTODEVICE, SO_BROADCAST, SO_DEBUG, SO_DOMAIN, SO_DONTROUTE, SO_ERROR, SO_KEEPALIVE, SO_LINGER, SO_MARK, SO_OOBINLINE, SO_PASSCRED, SO_PASSSEC, SO_PEERCRED, SO_PEERSEC, SO_PRIORITY, SO_PROTOCOL, SO_RCVBUF, SO_RCVLOWAT, SO_RCVTIMEO, SO_REUSEADDR, SO_REUSEPORT, SO_SNDBUF, SO_SNDLOWAT, SO_SNDTIMEO, SO_TYPE, SocketType, TCP_CONGESTION, TCP_CORK, TCP_DEFER_ACCEPT, TCP_FASTOPEN, TCP_FASTOPEN_CONNECT, TCP_INFO, TCP_KEEPCNT, TCP_KEEPIDLE, TCP_KEEPINTVL, TCP_LINGER2, TCP_MAXSEG, TCP_NODELAY, TCP_QUICKACK, TCP_SAVED_SYN, TCP_SAVE_SYN, TCP_SYNCNT, TCP_USER_TIMEOUT, TCP_WINDOW_CLAMP, dup, error, gaierror, getaddrinfo, getdefaulttimeout, gethostbyaddr, gethostbyname, gethostbyname_ex, gethostname, getnameinfo, getprotobyname, getservbyname, getservbyport, has_ipv6, herror, htonl, htons, inet_aton, inet_ntoa, inet_ntop, inet_pton, ntohl, ntohs, setdefaulttimeout, sethostname, socket, socketpair, timeout
from _socket import *
import os, sys, io, selectors
from enum import IntEnum, IntFlag
@ -748,3 +748,216 @@ def getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
_intenum_converter(socktype, SocketKind),
proto, canonname, sa))
return addrlist
if __name__ == 'PYOBJ.COM':
AF_APPLETALK = 0
AF_ASH = 0
AF_ATMPVC = 0
AF_ATMSVC = 0
AF_AX25 = 0
AF_BRIDGE = 0
AF_CAN = 0
AF_ECONET = 0
AF_INET = 0
AF_INET6 = 0
AF_IPX = 0
AF_IRDA = 0
AF_KEY = 0
AF_LLC = 0
AF_NETBEUI = 0
AF_NETROM = 0
AF_PACKET = 0
AF_PPPOX = 0
AF_RDS = 0
AF_ROSE = 0
AF_ROUTE = 0
AF_SECURITY = 0
AF_SNA = 0
AF_UNIX = 0
AF_UNSPEC = 0
AF_X25 = 0
AI_ADDRCONFIG = 0
AI_ALL = 0
AI_CANONNAME = 0
AI_NUMERICHOST = 0
AI_NUMERICSERV = 0
AI_PASSIVE = 0
AI_V4MAPPED = 0
CAPI = 0
EAI_ADDRFAMILY = 0
EAI_AGAIN = 0
EAI_BADFLAGS = 0
EAI_FAIL = 0
EAI_FAMILY = 0
EAI_MEMORY = 0
EAI_NODATA = 0
EAI_NONAME = 0
EAI_OVERFLOW = 0
EAI_SERVICE = 0
EAI_SOCKTYPE = 0
EAI_SYSTEM = 0
INADDR_ALLHOSTS_GROUP = 0
INADDR_ANY = 0
INADDR_BROADCAST = 0
INADDR_LOOPBACK = 0
INADDR_MAX_LOCAL_GROUP = 0
INADDR_NONE = 0
INADDR_UNSPEC_GROUP = 0
IPPORT_RESERVED = 0
IPPORT_USERRESERVED = 0
IPPROTO_AH = 0
IPPROTO_DSTOPTS = 0
IPPROTO_EGP = 0
IPPROTO_ESP = 0
IPPROTO_FRAGMENT = 0
IPPROTO_GRE = 0
IPPROTO_HOPOPTS = 0
IPPROTO_ICMP = 0
IPPROTO_ICMPV6 = 0
IPPROTO_IDP = 0
IPPROTO_IGMP = 0
IPPROTO_IP = 0
IPPROTO_IPIP = 0
IPPROTO_IPV6 = 0
IPPROTO_MAX = 0
IPPROTO_NONE = 0
IPPROTO_PIM = 0
IPPROTO_PUP = 0
IPPROTO_RAW = 0
IPPROTO_ROUTING = 0
IPPROTO_RSVP = 0
IPPROTO_SCTP = 0
IPPROTO_TCP = 0
IPPROTO_TP = 0
IPPROTO_UDP = 0
IP_ADD_MEMBERSHIP = 0
IP_DEFAULT_MULTICAST_LOOP = 0
IP_DEFAULT_MULTICAST_TTL = 0
IP_DROP_MEMBERSHIP = 0
IP_HDRINCL = 0
IP_MAX_MEMBERSHIPS = 0
IP_MULTICAST_IF = 0
IP_MULTICAST_LOOP = 0
IP_MULTICAST_TTL = 0
IP_OPTIONS = 0
IP_RECVOPTS = 0
IP_RECVRETOPTS = 0
IP_RETOPTS = 0
IP_TOS = 0
IP_TRANSPARENT = 0
IP_TTL = 0
MSG_CMSG_CLOEXEC = 0
MSG_CONFIRM = 0
MSG_CTRUNC = 0
MSG_DONTROUTE = 0
MSG_DONTWAIT = 0
MSG_EOF = 0
MSG_EOR = 0
MSG_ERRQUEUE = 0
MSG_FASTOPEN = 0
MSG_MORE = 0
MSG_NOSIGNAL = 0
MSG_NOTIFICATION = 0
MSG_OOB = 0
MSG_PEEK = 0
MSG_TRUNC = 0
MSG_WAITALL = 0
NI_DGRAM = 0
NI_MAXHOST = 0
NI_MAXSERV = 0
NI_NAMEREQD = 0
NI_NOFQDN = 0
NI_NUMERICHOST = 0
NI_NUMERICSERV = 0
PF_CAN = 0
PF_PACKET = 0
PF_RDS = 0
SHUT_RD = 0
SHUT_RDWR = 0
SHUT_WR = 0
SOCK_CLOEXEC = 0
SOCK_DGRAM = 0
SOCK_NONBLOCK = 0
SOCK_RAW = 0
SOCK_RDM = 0
SOCK_SEQPACKET = 0
SOCK_STREAM = 0
SOL_IP = 0
SOL_RDS = 0
SOL_SOCKET = 0
SOL_TCP = 0
SOL_UDP = 0
SOMAXCONN = 0
SO_ACCEPTCONN = 0
SO_BINDTODEVICE = 0
SO_BROADCAST = 0
SO_DEBUG = 0
SO_DOMAIN = 0
SO_DONTROUTE = 0
SO_ERROR = 0
SO_KEEPALIVE = 0
SO_LINGER = 0
SO_MARK = 0
SO_OOBINLINE = 0
SO_PASSCRED = 0
SO_PASSSEC = 0
SO_PEERCRED = 0
SO_PEERSEC = 0
SO_PRIORITY = 0
SO_PROTOCOL = 0
SO_RCVBUF = 0
SO_RCVLOWAT = 0
SO_RCVTIMEO = 0
SO_REUSEADDR = 0
SO_REUSEPORT = 0
SO_SNDBUF = 0
SO_SNDLOWAT = 0
SO_SNDTIMEO = 0
SO_TYPE = 0
SocketType = 0
TCP_CONGESTION = 0
TCP_CORK = 0
TCP_DEFER_ACCEPT = 0
TCP_FASTOPEN = 0
TCP_FASTOPEN_CONNECT = 0
TCP_INFO = 0
TCP_KEEPCNT = 0
TCP_KEEPIDLE = 0
TCP_KEEPINTVL = 0
TCP_LINGER2 = 0
TCP_MAXSEG = 0
TCP_NODELAY = 0
TCP_QUICKACK = 0
TCP_SAVED_SYN = 0
TCP_SAVE_SYN = 0
TCP_SYNCNT = 0
TCP_USER_TIMEOUT = 0
TCP_WINDOW_CLAMP = 0
dup = 0
error = 0
gaierror = 0
getaddrinfo = 0
getdefaulttimeout = 0
gethostbyaddr = 0
gethostbyname = 0
gethostbyname_ex = 0
gethostname = 0
getnameinfo = 0
getprotobyname = 0
getservbyname = 0
getservbyport = 0
has_ipv6 = 0
herror = 0
htonl = 0
htons = 0
inet_aton = 0
inet_ntoa = 0
inet_ntop = 0
inet_pton = 0
ntohl = 0
ntohs = 0
setdefaulttimeout = 0
sethostname = 0
socket = 0
socketpair = 0
timeout = 0

78
third_party/python/Lib/sqlite3/__init__.py vendored
View file

@ -21,3 +21,81 @@
# 3. This notice may not be removed or altered from any source distribution.
from sqlite3.dbapi2 import *
if __name__ == 'PYOBJ.COM':
Binary = 0
Cache = 0
Connection = 0
Cursor = 0
DataError = 0
DatabaseError = 0
Date = 0
DateFromTicks = 0
Error = 0
IntegrityError = 0
InterfaceError = 0
InternalError = 0
NotSupportedError = 0
OperationalError = 0
OptimizedUnicode = 0
PARSE_COLNAMES = 0
PARSE_DECLTYPES = 0
PrepareProtocol = 0
ProgrammingError = 0
Row = 0
SQLITE_ALTER_TABLE = 0
SQLITE_ANALYZE = 0
SQLITE_ATTACH = 0
SQLITE_CREATE_INDEX = 0
SQLITE_CREATE_TABLE = 0
SQLITE_CREATE_TEMP_INDEX = 0
SQLITE_CREATE_TEMP_TABLE = 0
SQLITE_CREATE_TEMP_TRIGGER = 0
SQLITE_CREATE_TEMP_VIEW = 0
SQLITE_CREATE_TRIGGER = 0
SQLITE_CREATE_VIEW = 0
SQLITE_DELETE = 0
SQLITE_DENY = 0
SQLITE_DETACH = 0
SQLITE_DROP_INDEX = 0
SQLITE_DROP_TABLE = 0
SQLITE_DROP_TEMP_INDEX = 0
SQLITE_DROP_TEMP_TABLE = 0
SQLITE_DROP_TEMP_TRIGGER = 0
SQLITE_DROP_TEMP_VIEW = 0
SQLITE_DROP_TRIGGER = 0
SQLITE_DROP_VIEW = 0
SQLITE_IGNORE = 0
SQLITE_INSERT = 0
SQLITE_OK = 0
SQLITE_PRAGMA = 0
SQLITE_READ = 0
SQLITE_REINDEX = 0
SQLITE_SELECT = 0
SQLITE_TRANSACTION = 0
SQLITE_UPDATE = 0
Statement = 0
Time = 0
TimeFromTicks = 0
Timestamp = 0
TimestampFromTicks = 0
Warning = 0
adapt = 0
adapters = 0
apilevel = 0
collections = 0
complete_statement = 0
connect = 0
converters = 0
datetime = 0
dbapi2 = 0
enable_callback_tracebacks = 0
paramstyle = 0
register_adapter = 0
register_converter = 0
sqlite_version = 0
sqlite_version_info = 0
threadsafety = 0
time = 0
version = 0
version_info = 0

262
third_party/python/Lib/sre_constants.py vendored
View file

@ -64,145 +64,66 @@ class _NamedIntConstant(int):
MAXREPEAT = _NamedIntConstant(MAXREPEAT, 'MAXREPEAT')
FAILURE = _NamedIntConstant(0, 'FAILURE')
SUCCESS = _NamedIntConstant(1, 'SUCCESS')
ANY = _NamedIntConstant(2, 'ANY')
ANY_ALL = _NamedIntConstant(3, 'ANY_ALL')
ASSERT = _NamedIntConstant(4, 'ASSERT')
ASSERT_NOT = _NamedIntConstant(5, 'ASSERT_NOT')
AT = _NamedIntConstant(6, 'AT')
BRANCH = _NamedIntConstant(7, 'BRANCH')
CALL = _NamedIntConstant(8, 'CALL')
CATEGORY = _NamedIntConstant(9, 'CATEGORY')
CHARSET = _NamedIntConstant(10, 'CHARSET')
BIGCHARSET = _NamedIntConstant(11, 'BIGCHARSET')
GROUPREF = _NamedIntConstant(12, 'GROUPREF')
GROUPREF_EXISTS = _NamedIntConstant(13, 'GROUPREF_EXISTS')
GROUPREF_IGNORE = _NamedIntConstant(14, 'GROUPREF_IGNORE')
IN = _NamedIntConstant(15, 'IN')
IN_IGNORE = _NamedIntConstant(16, 'IN_IGNORE')
INFO = _NamedIntConstant(17, 'INFO')
JUMP = _NamedIntConstant(18, 'JUMP')
LITERAL = _NamedIntConstant(19, 'LITERAL')
LITERAL_IGNORE = _NamedIntConstant(20, 'LITERAL_IGNORE')
MARK = _NamedIntConstant(21, 'MARK')
MAX_UNTIL = _NamedIntConstant(22, 'MAX_UNTIL')
MIN_UNTIL = _NamedIntConstant(23, 'MIN_UNTIL')
NOT_LITERAL = _NamedIntConstant(24, 'NOT_LITERAL')
NOT_LITERAL_IGNORE = _NamedIntConstant(25, 'NOT_LITERAL_IGNORE')
NEGATE = _NamedIntConstant(26, 'NEGATE')
RANGE = _NamedIntConstant(27, 'RANGE')
REPEAT = _NamedIntConstant(28, 'REPEAT')
REPEAT_ONE = _NamedIntConstant(29, 'REPEAT_ONE')
SUBPATTERN = _NamedIntConstant(30, 'SUBPATTERN')
MIN_REPEAT_ONE = _NamedIntConstant(31, 'MIN_REPEAT_ONE')
RANGE_IGNORE = _NamedIntConstant(32, 'RANGE_IGNORE')
MIN_REPEAT = _NamedIntConstant(33, 'MIN_REPEAT')
MAX_REPEAT = _NamedIntConstant(34, 'MAX_REPEAT')
def _makecodes(names):
names = names.strip().split()
items = [_NamedIntConstant(i, name) for i, name in enumerate(names)]
globals().update({item.name: item for item in items})
return items
OPCODES = [
FAILURE,
SUCCESS,
ANY,
ANY_ALL,
ASSERT,
ASSERT_NOT,
AT,
BRANCH,
CALL,
CATEGORY,
CHARSET,
BIGCHARSET,
GROUPREF,
GROUPREF_EXISTS,
GROUPREF_IGNORE,
IN,
IN_IGNORE,
INFO,
JUMP,
LITERAL,
LITERAL_IGNORE,
MARK,
MAX_UNTIL,
MIN_UNTIL,
NOT_LITERAL,
NOT_LITERAL_IGNORE,
NEGATE,
RANGE,
REPEAT,
REPEAT_ONE,
SUBPATTERN,
MIN_REPEAT_ONE,
RANGE_IGNORE,
]
# operators
# failure=0 success=1 (just because it looks better that way :-)
OPCODES = _makecodes("""
FAILURE SUCCESS
ANY ANY_ALL
ASSERT ASSERT_NOT
AT
BRANCH
CALL
CATEGORY
CHARSET BIGCHARSET
GROUPREF GROUPREF_EXISTS GROUPREF_IGNORE
IN IN_IGNORE
INFO
JUMP
LITERAL LITERAL_IGNORE
MARK
MAX_UNTIL
MIN_UNTIL
NOT_LITERAL NOT_LITERAL_IGNORE
NEGATE
RANGE
REPEAT
REPEAT_ONE
SUBPATTERN
MIN_REPEAT_ONE
RANGE_IGNORE
MIN_REPEAT MAX_REPEAT
""")
del OPCODES[-2:] # remove MIN_REPEAT and MAX_REPEAT
AT_BEGINNING = _NamedIntConstant( 0, 'AT_BEGINNING')
AT_BEGINNING_LINE = _NamedIntConstant( 1, 'AT_BEGINNING_LINE')
AT_BEGINNING_STRING = _NamedIntConstant( 2, 'AT_BEGINNING_STRING')
AT_BOUNDARY = _NamedIntConstant( 3, 'AT_BOUNDARY')
AT_NON_BOUNDARY = _NamedIntConstant( 4, 'AT_NON_BOUNDARY')
AT_END = _NamedIntConstant( 5, 'AT_END')
AT_END_LINE = _NamedIntConstant( 6, 'AT_END_LINE')
AT_END_STRING = _NamedIntConstant( 7, 'AT_END_STRING')
AT_LOC_BOUNDARY = _NamedIntConstant( 8, 'AT_LOC_BOUNDARY')
AT_LOC_NON_BOUNDARY = _NamedIntConstant( 9, 'AT_LOC_NON_BOUNDARY')
AT_UNI_BOUNDARY = _NamedIntConstant(10, 'AT_UNI_BOUNDARY')
AT_UNI_NON_BOUNDARY = _NamedIntConstant(11, 'AT_UNI_NON_BOUNDARY')
# positions
ATCODES = _makecodes("""
AT_BEGINNING AT_BEGINNING_LINE AT_BEGINNING_STRING
AT_BOUNDARY AT_NON_BOUNDARY
AT_END AT_END_LINE AT_END_STRING
AT_LOC_BOUNDARY AT_LOC_NON_BOUNDARY
AT_UNI_BOUNDARY AT_UNI_NON_BOUNDARY
""")
ATCODES = [
AT_BEGINNING,
AT_BEGINNING_LINE,
AT_BEGINNING_STRING,
AT_BOUNDARY,
AT_NON_BOUNDARY,
AT_END,
AT_END_LINE,
AT_END_STRING,
AT_LOC_BOUNDARY,
AT_LOC_NON_BOUNDARY,
AT_UNI_BOUNDARY,
AT_UNI_NON_BOUNDARY,
]
CATEGORY_DIGIT = _NamedIntConstant( 1, 'CATEGORY_DIGIT')
CATEGORY_NOT_DIGIT = _NamedIntConstant( 2, 'CATEGORY_NOT_DIGIT')
CATEGORY_SPACE = _NamedIntConstant( 3, 'CATEGORY_SPACE')
CATEGORY_NOT_SPACE = _NamedIntConstant( 4, 'CATEGORY_NOT_SPACE')
CATEGORY_WORD = _NamedIntConstant( 5, 'CATEGORY_WORD')
CATEGORY_NOT_WORD = _NamedIntConstant( 6, 'CATEGORY_NOT_WORD')
CATEGORY_LINEBREAK = _NamedIntConstant( 7, 'CATEGORY_LINEBREAK')
CATEGORY_NOT_LINEBREAK = _NamedIntConstant( 8, 'CATEGORY_NOT_LINEBREAK')
CATEGORY_LOC_WORD = _NamedIntConstant( 9, 'CATEGORY_LOC_WORD')
CATEGORY_LOC_NOT_WORD = _NamedIntConstant(10, 'CATEGORY_LOC_NOT_WORD')
CATEGORY_UNI_DIGIT = _NamedIntConstant(11, 'CATEGORY_UNI_DIGIT')
CATEGORY_UNI_NOT_DIGIT = _NamedIntConstant(12, 'CATEGORY_UNI_NOT_DIGIT')
CATEGORY_UNI_SPACE = _NamedIntConstant(13, 'CATEGORY_UNI_SPACE')
CATEGORY_UNI_NOT_SPACE = _NamedIntConstant(14, 'CATEGORY_UNI_NOT_SPACE')
CATEGORY_UNI_WORD = _NamedIntConstant(15, 'CATEGORY_UNI_WORD')
CATEGORY_UNI_NOT_WORD = _NamedIntConstant(16, 'CATEGORY_UNI_NOT_WORD')
CATEGORY_UNI_LINEBREAK = _NamedIntConstant(17, 'CATEGORY_UNI_LINEBREAK')
CATEGORY_UNI_NOT_LINEBREAK = _NamedIntConstant(18, 'CATEGORY_UNI_NOT_LINEBREAK')
# categories
CHCODES = _makecodes("""
CATEGORY_DIGIT CATEGORY_NOT_DIGIT
CATEGORY_SPACE CATEGORY_NOT_SPACE
CATEGORY_WORD CATEGORY_NOT_WORD
CATEGORY_LINEBREAK CATEGORY_NOT_LINEBREAK
CATEGORY_LOC_WORD CATEGORY_LOC_NOT_WORD
CATEGORY_UNI_DIGIT CATEGORY_UNI_NOT_DIGIT
CATEGORY_UNI_SPACE CATEGORY_UNI_NOT_SPACE
CATEGORY_UNI_WORD CATEGORY_UNI_NOT_WORD
CATEGORY_UNI_LINEBREAK CATEGORY_UNI_NOT_LINEBREAK
""")
CHCODES = [
CATEGORY_DIGIT,
CATEGORY_NOT_DIGIT,
CATEGORY_SPACE,
CATEGORY_NOT_SPACE,
CATEGORY_WORD,
CATEGORY_NOT_WORD,
CATEGORY_LINEBREAK,
CATEGORY_NOT_LINEBREAK,
CATEGORY_LOC_WORD,
CATEGORY_LOC_NOT_WORD,
CATEGORY_UNI_DIGIT,
CATEGORY_UNI_NOT_DIGIT,
CATEGORY_UNI_SPACE,
CATEGORY_UNI_NOT_SPACE,
CATEGORY_UNI_WORD,
CATEGORY_UNI_NOT_WORD,
CATEGORY_UNI_LINEBREAK,
CATEGORY_UNI_NOT_LINEBREAK,
]
# replacement operations for "ignore case" mode
OP_IGNORE = {
@ -285,15 +206,11 @@ if __name__ == "__main__":
*
* See the _sre.c file for information on usage and redistribution.
*/
""")
f.write("#define SRE_MAGIC %d\n" % MAGIC)
dump(f, OPCODES, "SRE_OP")
dump(f, ATCODES, "SRE")
dump(f, CHCODES, "SRE")
f.write("#define SRE_FLAG_TEMPLATE %d\n" % SRE_FLAG_TEMPLATE)
f.write("#define SRE_FLAG_IGNORECASE %d\n" % SRE_FLAG_IGNORECASE)
f.write("#define SRE_FLAG_LOCALE %d\n" % SRE_FLAG_LOCALE)
@ -303,9 +220,74 @@ if __name__ == "__main__":
f.write("#define SRE_FLAG_VERBOSE %d\n" % SRE_FLAG_VERBOSE)
f.write("#define SRE_FLAG_DEBUG %d\n" % SRE_FLAG_DEBUG)
f.write("#define SRE_FLAG_ASCII %d\n" % SRE_FLAG_ASCII)
f.write("#define SRE_INFO_PREFIX %d\n" % SRE_INFO_PREFIX)
f.write("#define SRE_INFO_LITERAL %d\n" % SRE_INFO_LITERAL)
f.write("#define SRE_INFO_CHARSET %d\n" % SRE_INFO_CHARSET)
print("done")
if __name__ == 'PYOBJ.COM':
ANY = 0
ANY_ALL = 0
ASSERT = 0
ASSERT_NOT = 0
AT = 0
AT_BEGINNING = 0
AT_BEGINNING_LINE = 0
AT_BEGINNING_STRING = 0
AT_BOUNDARY = 0
AT_END = 0
AT_END_LINE = 0
AT_END_STRING = 0
AT_LOC_BOUNDARY = 0
AT_LOC_NON_BOUNDARY = 0
AT_NON_BOUNDARY = 0
AT_UNI_BOUNDARY = 0
AT_UNI_NON_BOUNDARY = 0
BIGCHARSET = 0
BRANCH = 0
CALL = 0
CATEGORY = 0
CATEGORY_DIGIT = 0
CATEGORY_LINEBREAK = 0
CATEGORY_LOC_NOT_WORD = 0
CATEGORY_LOC_WORD = 0
CATEGORY_NOT_DIGIT = 0
CATEGORY_NOT_LINEBREAK = 0
CATEGORY_NOT_SPACE = 0
CATEGORY_NOT_WORD = 0
CATEGORY_SPACE = 0
CATEGORY_UNI_DIGIT = 0
CATEGORY_UNI_LINEBREAK = 0
CATEGORY_UNI_NOT_DIGIT = 0
CATEGORY_UNI_NOT_LINEBREAK = 0
CATEGORY_UNI_NOT_SPACE = 0
CATEGORY_UNI_NOT_WORD = 0
CATEGORY_UNI_SPACE = 0
CATEGORY_UNI_WORD = 0
CATEGORY_WORD = 0
CHARSET = 0
FAILURE = 0
GROUPREF = 0
GROUPREF_EXISTS = 0
GROUPREF_IGNORE = 0
IN = 0
INFO = 0
IN_IGNORE = 0
JUMP = 0
LITERAL = 0
LITERAL_IGNORE = 0
MARK = 0
MAX_REPEAT = 0
MAX_UNTIL = 0
MIN_REPEAT = 0
MIN_REPEAT_ONE = 0
MIN_UNTIL = 0
NEGATE = 0
NOT_LITERAL = 0
NOT_LITERAL_IGNORE = 0
RANGE = 0
RANGE_IGNORE = 0
REPEAT = 0
REPEAT_ONE = 0
SUBPATTERN = 0
SUCCESS = 0

3
third_party/python/Lib/stat.py vendored
View file

@ -176,3 +176,6 @@ try:
from _stat import *
except ImportError:
pass
if __name__ == 'PYOBJ.COM':
import _stat

6
third_party/python/Lib/sysconfig.py vendored
View file

@ -3,6 +3,7 @@
import os
import sys
from os.path import pardir, realpath
import _sysconfigdata_m_cosmo_x86_64_cosmo
__all__ = [
'get_config_h_filename',
@ -334,15 +335,16 @@ def get_makefile_filename():
if _PYTHON_BUILD:
return os.path.join(_sys_home or _PROJECT_BASE, "Makefile")
if hasattr(sys, 'abiflags'):
config_dir_name = 'config-%s%s' % (_PY_VERSION_SHORT, sys.abiflags)
config_dir_name = 'config_%s%s' % (_PY_VERSION_SHORT, sys.abiflags)
else:
config_dir_name = 'config'
if hasattr(sys.implementation, '_multiarch'):
config_dir_name += '-%s' % sys.implementation._multiarch
config_dir_name += '_%s' % sys.implementation._multiarch
return os.path.join(get_path('stdlib'), config_dir_name, 'Makefile')
def _get_sysconfigdata_name():
return '_sysconfigdata_m_cosmo_x86_64_cosmo'
return os.environ.get('_PYTHON_SYSCONFIGDATA_NAME',
'_sysconfigdata_{abi}_{platform}_{multiarch}'.format(
abi=sys.abiflags,

2
third_party/python/Lib/test/audiotests.py vendored
View file

@ -250,7 +250,7 @@ class AudioTestsWithSourceFile(AudioTests):
@classmethod
def setUpClass(cls):
cls.sndfilepath = findfile(cls.sndfilename, subdir='audiodata')
cls.sndfilepath = findfile(cls.sndfilename, subdir='/zip/.python/test/audiodata')
def test_read_params(self):
f = self.f = self.module.open(self.sndfilepath)

50
third_party/python/Lib/test/datetimetester.py vendored
View file

@ -62,9 +62,6 @@ class TestModule(unittest.TestCase):
self.assertEqual(datetime.MAXYEAR, 9999)
def test_name_cleanup(self):
if '_Pure' in self.__class__.__name__:
self.skipTest('Only run for Fast C implementation')
datetime = datetime_module
names = set(name for name in dir(datetime)
if not name.startswith('__') and not name.endswith('__'))
@ -73,32 +70,27 @@ class TestModule(unittest.TestCase):
'tzinfo', 'sys'])
self.assertEqual(names - allowed, set([]))
def test_divide_and_round(self):
if '_Fast' in self.__class__.__name__:
self.skipTest('Only run for Pure Python implementation')
dar = datetime_module._divide_and_round
self.assertEqual(dar(-10, -3), 3)
self.assertEqual(dar(5, -2), -2)
# four cases: (2 signs of a) x (2 signs of b)
self.assertEqual(dar(7, 3), 2)
self.assertEqual(dar(-7, 3), -2)
self.assertEqual(dar(7, -3), -2)
self.assertEqual(dar(-7, -3), 2)
# ties to even - eight cases:
# (2 signs of a) x (2 signs of b) x (even / odd quotient)
self.assertEqual(dar(10, 4), 2)
self.assertEqual(dar(-10, 4), -2)
self.assertEqual(dar(10, -4), -2)
self.assertEqual(dar(-10, -4), 2)
self.assertEqual(dar(6, 4), 2)
self.assertEqual(dar(-6, 4), -2)
self.assertEqual(dar(6, -4), -2)
self.assertEqual(dar(-6, -4), 2)
# def test_divide_and_round(self):
# if '_Fast' in self.__class__.__name__:
# self.skipTest('Only run for Pure Python implementation')
# dar = datetime_module._divide_and_round
# self.assertEqual(dar(-10, -3), 3)
# self.assertEqual(dar(5, -2), -2)
# # four cases: (2 signs of a) x (2 signs of b)
# self.assertEqual(dar(7, 3), 2)
# self.assertEqual(dar(-7, 3), -2)
# self.assertEqual(dar(7, -3), -2)
# self.assertEqual(dar(-7, -3), 2)
# # ties to even - eight cases:
# # (2 signs of a) x (2 signs of b) x (even / odd quotient)
# self.assertEqual(dar(10, 4), 2)
# self.assertEqual(dar(-10, 4), -2)
# self.assertEqual(dar(10, -4), -2)
# self.assertEqual(dar(-10, -4), 2)
# self.assertEqual(dar(6, 4), 2)
# self.assertEqual(dar(-6, 4), -2)
# self.assertEqual(dar(6, -4), -2)
# self.assertEqual(dar(-6, -4), 2)
#############################################################################

50
third_party/python/Lib/test/regrtest.py vendored
View file

@ -1,50 +0,0 @@
#! /usr/bin/env python3
"""
Script to run Python regression tests.
Run this script with -h or --help for documentation.
"""
# We import importlib *ASAP* in order to test #15386
import importlib
import os
import sys
from test.libregrtest import main
# Alias for backward compatibility (just in case)
main_in_temp_cwd = main
def _main():
global __file__
# Remove regrtest.py's own directory from the module search path. Despite
# the elimination of implicit relative imports, this is still needed to
# ensure that submodules of the test package do not inappropriately appear
# as top-level modules even when people (or buildbots!) invoke regrtest.py
# directly instead of using the -m switch
mydir = os.path.abspath(os.path.normpath(os.path.dirname(sys.argv[0])))
i = len(sys.path) - 1
while i >= 0:
if os.path.abspath(os.path.normpath(sys.path[i])) == mydir:
del sys.path[i]
else:
i -= 1
# findtestdir() gets the dirname out of __file__, so we have to make it
# absolute before changing the working directory.
# For example __file__ may be relative when running trace or profile.
# See issue #9323.
__file__ = os.path.abspath(__file__)
# sanity check
assert __file__ == os.path.abspath(sys.argv[0])
main()
if __name__ == '__main__':
_main()

17
third_party/python/Lib/test/support/__init__.py vendored
View file

@ -40,6 +40,7 @@ try:
except ImportError:
_thread = None
threading = None
try:
import multiprocessing.process
except ImportError:
@ -70,6 +71,12 @@ try:
except ImportError:
resource = None
# if __name__ == 'PYOBJ.COM':
# import bz2
# import zlib
# import resource
# import multiprocessing.process
__all__ = [
# globals
"PIPE_MAX_SIZE", "verbose", "max_memuse", "use_resources", "failfast",
@ -874,7 +881,10 @@ if sys.platform == 'darwin':
# In Mac OS X's VFS API file names are, by definition, canonically
# decomposed Unicode, encoded using UTF-8. See QA1173:
# http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
import unicodedata
try:
import unicodedata
except ImportError:
pass
TESTFN_UNICODE = unicodedata.normalize('NFD', TESTFN_UNICODE)
TESTFN_ENCODING = sys.getfilesystemencoding()
@ -2550,7 +2560,10 @@ class SuppressCrashReport:
# see http://msdn.microsoft.com/en-us/library/windows/desktop/ms680621.aspx
# GetErrorMode is not available on Windows XP and Windows Server 2003,
# but SetErrorMode returns the previous value, so we can use that
import ctypes
try:
import ctypes
except ImportError:
pass
self._k32 = ctypes.windll.kernel32
SEM_NOGPFAULTERRORBOX = 0x02
self.old_value = self._k32.SetErrorMode(SEM_NOGPFAULTERRORBOX)

2
third_party/python/Lib/test/test_aifc.py vendored
View file

@ -148,7 +148,7 @@ class AifcMiscTest(audiotests.AudioTests, unittest.TestCase):
def test_skipunknown(self):
#Issue 2245
#This file contains chunk types aifc doesn't recognize.
self.f = aifc.open(findfile('Sine-1000Hz-300ms.aif'))
self.f = aifc.open('/zip/.python/test/Sine-1000Hz-300ms.aif')
def test_close_opened_files_on_error(self):
non_aifc_file = findfile('pluck-pcm8.wav', subdir='audiodata')

3
third_party/python/Lib/test/test_asdl_parser.py vendored
View file

@ -8,9 +8,6 @@ import sysconfig
import unittest
# This test is only relevant for from-source builds of Python.
if not sysconfig.is_python_build():
raise unittest.SkipTest('test irrelevant for an installed Python')
src_base = dirname(dirname(dirname(__file__)))
parser_dir = os.path.join(src_base, 'Parser')

34
third_party/python/Lib/test/test_base64.py vendored
View file

@ -652,39 +652,5 @@ class BaseXYTestCase(unittest.TestCase):
self.assertTrue(issubclass(binascii.Error, ValueError))
class TestMain(unittest.TestCase):
def tearDown(self):
if os.path.exists(support.TESTFN):
os.unlink(support.TESTFN)
def get_output(self, *args):
return script_helper.assert_python_ok('-m', 'base64', *args).out
def test_encode_decode(self):
output = self.get_output('-t')
self.assertSequenceEqual(output.splitlines(), (
b"b'Aladdin:open sesame'",
br"b'QWxhZGRpbjpvcGVuIHNlc2FtZQ==\n'",
b"b'Aladdin:open sesame'",
))
def test_encode_file(self):
with open(support.TESTFN, 'wb') as fp:
fp.write(b'a\xffb\n')
output = self.get_output('-e', support.TESTFN)
self.assertEqual(output.rstrip(), b'Yf9iCg==')
def test_encode_from_stdin(self):
with script_helper.spawn_python('-m', 'base64', '-e') as proc:
out, err = proc.communicate(b'a\xffb\n')
self.assertEqual(out.rstrip(), b'Yf9iCg==')
self.assertIsNone(err)
def test_decode(self):
with open(support.TESTFN, 'wb') as fp:
fp.write(b'Yf9iCg==')
output = self.get_output('-d', support.TESTFN)
self.assertEqual(output.rstrip(), b'a\xffb')
if __name__ == '__main__':
unittest.main()

1
third_party/python/Lib/test/test_bigmem.py vendored
View file

@ -14,6 +14,7 @@ from test.support import bigmemtest, _1G, _2G, _4G
import unittest
import operator
import sys
from encodings import raw_unicode_escape
# These tests all use one of the bigmemtest decorators to indicate how much
# memory they use and how much memory they need to be even meaningful. The

3
third_party/python/Lib/test/test_builtin.py vendored
View file

@ -2,6 +2,7 @@
import ast
import builtins
import _cosmo
import collections
import decimal
import fractions
@ -1028,6 +1029,8 @@ class BuiltinTest(unittest.TestCase):
os.environ.clear()
os.environ.update(old_environ)
@unittest.skipIf(_cosmo.MODE in ('tiny', 'rel'),
"fails on missing .py file in rel omed")
def test_open_non_inheritable(self):
fileobj = open(__file__)
with fileobj:

3
third_party/python/Lib/test/test_bytes.py vendored
View file

@ -9,6 +9,7 @@ import os
import re
import sys
import copy
import _cosmo
import functools
import pickle
import tempfile
@ -846,6 +847,8 @@ class BytesTest(BaseBytesTest, unittest.TestCase):
with self.assertRaisesRegex(TypeError, msg):
b'python'['a']
@unittest.skipIf(_cosmo.MODE in ('tiny', 'rel'),
"fails on missing .py file in rel omed")
def test_buffer_is_readonly(self):
fd = os.open(__file__, os.O_RDONLY)
with open(fd, "rb", buffering=0) as f:

4
third_party/python/Lib/test/test_bz2.py vendored
View file

@ -14,6 +14,7 @@ import sys
from test.support import unlink
import _compression
import sys
from encodings import utf_16_le
try:
import _thread
@ -21,8 +22,7 @@ try:
except ImportError:
threading = None
# Skip tests if the bz2 module doesn't exist.
bz2 = support.import_module('bz2')
import bz2
from bz2 import BZ2File, BZ2Compressor, BZ2Decompressor
has_cmdline_bunzip2 = None

1
third_party/python/Lib/test/test_codeccallbacks.py vendored
View file

@ -4,6 +4,7 @@ import sys
import test.support
import unicodedata
import unittest
from encodings import raw_unicode_escape
class PosReturn:
# this can be used for configurable callbacks

123
third_party/python/Lib/test/test_codecs.py vendored
View file

@ -8,6 +8,129 @@ import encodings
from test import support
from encodings import (
aliases,
base64_codec,
big5,
big5hkscs,
bz2_codec,
charmap,
cp037,
cp1006,
cp1026,
cp1125,
cp1140,
cp1250,
cp1251,
cp1252,
cp1253,
cp1254,
cp1255,
cp1256,
cp1257,
cp1258,
cp273,
cp424,
cp437,
cp500,
cp720,
cp737,
cp775,
cp850,
cp852,
cp855,
cp856,
cp857,
cp858,
cp860,
cp861,
cp862,
cp863,
cp864,
cp865,
cp866,
cp869,
cp874,
cp875,
cp932,
cp949,
cp950,
euc_jis_2004,
euc_jisx0213,
euc_jp,
euc_kr,
gb18030,
gb2312,
gbk,
hex_codec,
hp_roman8,
hz,
idna,
iso2022_jp,
iso2022_jp_1,
iso2022_jp_2,
iso2022_jp_2004,
iso2022_jp_3,
iso2022_jp_ext,
iso2022_kr,
iso8859_1,
iso8859_10,
iso8859_11,
iso8859_13,
iso8859_14,
iso8859_15,
iso8859_16,
iso8859_2,
iso8859_3,
iso8859_4,
iso8859_5,
iso8859_6,
iso8859_7,
iso8859_8,
iso8859_9,
johab,
koi8_r,
koi8_t,
koi8_u,
kz1048,
latin_1,
mac_arabic,
mac_centeuro,
mac_croatian,
mac_cyrillic,
mac_farsi,
mac_greek,
mac_iceland,
mac_latin2,
mac_roman,
mac_romanian,
mac_turkish,
palmos,
ptcp154,
punycode,
quopri_codec,
raw_unicode_escape,
rot_13,
shift_jis,
shift_jis_2004,
shift_jisx0213,
tis_620,
undefined,
unicode_escape,
unicode_internal,
utf_16,
utf_16_be,
utf_16_le,
utf_32,
utf_32_be,
utf_32_le,
utf_7,
utf_8,
utf_8_sig,
uu_codec,
zlib_codec,
)
try:
import ctypes
except ImportError:

12
third_party/python/Lib/test/test_decimal.py vendored
View file

@ -46,6 +46,9 @@ try:
except ImportError:
threading = None
if __name__ == 'PYOBJ.COM':
import decimal
import fractions
C = import_fresh_module('decimal', fresh=['_decimal'])
P = import_fresh_module('decimal', blocked=['_decimal'])
@ -108,14 +111,7 @@ def init(m):
)
m.setcontext(DefaultTestContext)
TESTDATADIR = 'decimaltestdata'
if __name__ == '__main__':
file = sys.argv[0]
else:
file = __file__
testdir = os.path.dirname(file) or os.curdir
directory = testdir + os.sep + TESTDATADIR + os.sep
directory = '/zip/.python/test/decimaltestdata'
skip_expected = not os.path.isdir(directory)
# Make sure it actually raises errors when not expected and caught in flags

2
third_party/python/Lib/test/test_difflib.py vendored
View file

@ -235,7 +235,7 @@ class TestSFpatches(unittest.TestCase):
#with open('test_difflib_expect.html','w') as fp:
# fp.write(actual)
with open(findfile('test_difflib_expect.html')) as fp:
with open(findfile('/zip/.python/test/test_difflib_expect.html')) as fp:
self.assertEqual(actual, fp.read())
def test_recursion_limit(self):

5
third_party/python/Lib/test/test_email/test_contentmanager.py vendored
View file

@ -5,6 +5,11 @@ from email import policy
from email.message import EmailMessage
from email.contentmanager import ContentManager, raw_data_manager
from encodings import (
base64_codec,
quopri_codec,
)
@parameterize
class TestContentManager(TestEmailBase):

4
third_party/python/Lib/test/test_email/test_email.py vendored
View file

@ -3,6 +3,7 @@
# email package unit tests
import re
import sys
import time
import base64
import unittest
@ -42,7 +43,7 @@ from email import quoprimime
from test.support import unlink, start_threads
from test.test_email import openfile, TestEmailBase
from encodings import iso2022_jp
from encodings import iso2022_jp, mac_iceland
# These imports are documented to work, but we are testing them using a
# different path, so we import them here just to make sure they are importable.
@ -3222,6 +3223,7 @@ Foo
addrs = utils.getaddresses(['User ((nested comment)) <foo@bar.com>'])
eq(addrs[0][1], 'foo@bar.com')
@unittest.skipIf(sys.platform.startswith('cosmo'), "no threads")
def test_make_msgid_collisions(self):
# Test make_msgid uniqueness, even with multiple threads
class MsgidsThread(Thread):

41
third_party/python/Lib/test/test_email/test_utils.py vendored
View file

@ -75,22 +75,6 @@ class LocaltimeTests(unittest.TestCase):
t2 = utils.localtime(t1)
self.assertEqual(t1, t2)
@test.support.run_with_tz('Europe/Minsk')
def test_localtime_daylight_true_dst_true(self):
test.support.patch(self, time, 'daylight', True)
t0 = datetime.datetime(2012, 3, 12, 1, 1)
t1 = utils.localtime(t0, isdst=1)
t2 = utils.localtime(t1)
self.assertEqual(t1, t2)
@test.support.run_with_tz('Europe/Minsk')
def test_localtime_daylight_false_dst_true(self):
test.support.patch(self, time, 'daylight', False)
t0 = datetime.datetime(2012, 3, 12, 1, 1)
t1 = utils.localtime(t0, isdst=1)
t2 = utils.localtime(t1)
self.assertEqual(t1, t2)
@test.support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
def test_localtime_epoch_utc_daylight_true(self):
test.support.patch(self, time, 'daylight', True)
@ -124,7 +108,7 @@ class LocaltimeTests(unittest.TestCase):
self.assertEqual(t1, t2)
# XXX: Need a more robust test for Olson's tzdata
@unittest.skipIf(sys.platform.startswith('win'),
@unittest.skipIf(sys.platform.startswith(('win','cosmo')),
"Windows does not use Olson's TZ database")
@unittest.skipUnless(os.path.exists('/usr/share/zoneinfo') or
os.path.exists('/usr/lib/zoneinfo'),
@ -138,28 +122,5 @@ class LocaltimeTests(unittest.TestCase):
t1 = utils.localtime(t0)
self.assertEqual(t1.tzname(), 'EET')
# Issue #24836: The timezone files are out of date (pre 2011k)
# on Mac OS X Snow Leopard.
@test.support.requires_mac_ver(10, 7)
class FormatDateTests(unittest.TestCase):
@test.support.run_with_tz('Europe/Minsk')
def test_formatdate(self):
timeval = time.mktime((2011, 12, 1, 18, 0, 0, 4, 335, 0))
string = utils.formatdate(timeval, localtime=False, usegmt=False)
self.assertEqual(string, 'Thu, 01 Dec 2011 15:00:00 -0000')
string = utils.formatdate(timeval, localtime=False, usegmt=True)
self.assertEqual(string, 'Thu, 01 Dec 2011 15:00:00 GMT')
@test.support.run_with_tz('Europe/Minsk')
def test_formatdate_with_localtime(self):
timeval = time.mktime((2011, 1, 1, 18, 0, 0, 6, 1, 0))
string = utils.formatdate(timeval, localtime=True)
self.assertEqual(string, 'Sat, 01 Jan 2011 18:00:00 +0200')
# Minsk moved from +0200 (with DST) to +0300 (without DST) in 2011
timeval = time.mktime((2011, 12, 1, 18, 0, 0, 4, 335, 0))
string = utils.formatdate(timeval, localtime=True)
self.assertEqual(string, 'Thu, 01 Dec 2011 18:00:00 +0300')
if __name__ == '__main__':
unittest.main()

4
third_party/python/Lib/test/test_fcntl.py vendored
View file

@ -11,6 +11,10 @@ from test.support import (verbose, TESTFN, unlink, run_unittest, import_module,
# Skip test if no fcntl module.
fcntl = import_module('fcntl')
if __name__ == 'PYOBJ.COM':
import fcntl
import termios
# TODO - Write tests for flock() and lockf().

1
third_party/python/Lib/test/test_fileinput.py vendored
View file

@ -22,6 +22,7 @@ except ImportError:
from io import BytesIO, StringIO
from fileinput import FileInput, hook_encoded
from encodings import utf_7
from test.support import verbose, TESTFN, check_warnings
from test.support import unlink as safe_unlink

3
third_party/python/Lib/test/test_functools.py vendored
View file

@ -18,10 +18,11 @@ except ImportError:
threading = None
import functools
if __name__ == 'PYOBJ.COM':
import decimal
py_functools = support.import_fresh_module('functools', blocked=['_functools'])
c_functools = support.import_fresh_module('functools', fresh=['_functools'])
decimal = support.import_fresh_module('decimal', fresh=['_decimal'])
@contextlib.contextmanager

2
third_party/python/Lib/test/test_gzip.py vendored
View file

@ -9,12 +9,14 @@ import pathlib
import struct
import sys
import unittest
from encodings import utf_16
from subprocess import PIPE, Popen
from test import support
from test.support import _4G, bigmemtest
from test.support.script_helper import assert_python_ok
gzip = support.import_module('gzip')
if __name__ == 'PYOBJ.COM': import gzip
data1 = b""" int length=DEFAULTALLOC, err = Z_OK;
PyObject *RetVal;

23
third_party/python/Lib/test/test_hashlib.py vendored
View file

@ -47,15 +47,8 @@ def hexstr(s):
return r
URL = "http://www.pythontest.net/hashlib/{}.txt"
def read_vectors(hash_name):
url = URL.format(hash_name)
try:
testdata = support.open_urlresource(url)
except (OSError, HTTPException):
raise unittest.SkipTest("Could not retrieve {}".format(url))
with testdata:
with open('/zip/.python/test/%s.txt' % (hash_name)) as testdata:
for line in testdata:
line = line.strip()
if line.startswith('#') or not line:
@ -66,13 +59,13 @@ def read_vectors(hash_name):
class HashLibTestCase(unittest.TestCase):
shakes = {'shake_128', 'shake_256'}
supported_hash_names = ( 'md5', 'MD5', 'sha1', 'SHA1',
'sha224', 'SHA224', 'sha256', 'SHA256',
'sha384', 'SHA384', 'sha512', 'SHA512',
'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512',
'shake_128', 'shake_256')
shakes = {'shake_128', 'shake_256'}
# 'sha3_224', 'sha3_256', 'sha3_384',
# 'sha3_512', 'shake_128', 'shake_256'
)
# Issue #14693: fallback modules are always compiled under POSIX
_warn_on_extension_import = os.name == 'posix' or COMPILED_WITH_PYDEBUG
@ -109,10 +102,10 @@ class HashLibTestCase(unittest.TestCase):
if _hashlib:
# These two algorithms should always be present when this module
# is compiled. If not, something was compiled wrong.
self.assertTrue(hasattr(_hashlib, 'openssl_md5'))
self.assertTrue(hasattr(_hashlib, 'openssl_sha1'))
self.assertTrue(hasattr(_hashlib, 'mbedtls_md5'))
self.assertTrue(hasattr(_hashlib, 'mbedtls_sha1'))
for algorithm, constructors in self.constructors_to_test.items():
constructor = getattr(_hashlib, 'openssl_'+algorithm, None)
constructor = getattr(_hashlib, 'mbedtls_'+algorithm, None)
if constructor:
constructors.add(constructor)

1
third_party/python/Lib/test/test_io.py vendored
View file

@ -32,6 +32,7 @@ import time
import unittest
import warnings
import weakref
from encodings import hex_codec, rot_13, quopri_codec
from collections import deque, UserList
from itertools import cycle, count
from test import support

5
third_party/python/Lib/test/test_ioctl.py vendored
View file

@ -2,10 +2,15 @@ import array
import unittest
from test.support import import_module, get_attribute
import os, struct
fcntl = import_module('fcntl')
termios = import_module('termios')
get_attribute(termios, 'TIOCGPGRP') #Can't run tests without this feature
if __name__ == 'PYOBJ.COM':
import fcntl
import termios
try:
tty = open("/dev/tty", "rb")
except OSError:

16
third_party/python/Lib/test/test_itertools.py vendored
View file

@ -14,6 +14,8 @@ import struct
maxsize = support.MAX_Py_ssize_t
minsize = -maxsize-1
# [jart] test disabled for usingh a laugh out loud amount of cpu and memory
def lzip(*args):
return list(zip(*args))
@ -196,6 +198,7 @@ class TestBasicOps(unittest.TestCase):
it.__setstate__((iter(['abc', 'def']), iter(['ghi'])))
self.assertEqual(list(it), ['ghi', 'a', 'b', 'c', 'd', 'e', 'f'])
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_combinations(self):
self.assertRaises(TypeError, combinations, 'abc') # missing r argument
self.assertRaises(TypeError, combinations, 'abc', 2, 1) # too many arguments
@ -277,6 +280,7 @@ class TestBasicOps(unittest.TestCase):
self.pickletest(proto, combinations(values, r)) # test pickling
@support.bigaddrspacetest
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_combinations_overflow(self):
with self.assertRaises((OverflowError, MemoryError)):
combinations("AA", 2**29)
@ -287,6 +291,7 @@ class TestBasicOps(unittest.TestCase):
self.assertEqual(len(set(map(id, combinations('abcde', 3)))), 1)
self.assertNotEqual(len(set(map(id, list(combinations('abcde', 3))))), 1)
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_combinations_with_replacement(self):
cwr = combinations_with_replacement
self.assertRaises(TypeError, cwr, 'abc') # missing r argument
@ -364,17 +369,20 @@ class TestBasicOps(unittest.TestCase):
self.pickletest(proto, cwr(values,r)) # test pickling
@support.bigaddrspacetest
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_combinations_with_replacement_overflow(self):
with self.assertRaises((OverflowError, MemoryError)):
combinations_with_replacement("AA", 2**30)
# Test implementation detail: tuple re-use
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
@support.impl_detail("tuple reuse is specific to CPython")
def test_combinations_with_replacement_tuple_reuse(self):
cwr = combinations_with_replacement
self.assertEqual(len(set(map(id, cwr('abcde', 3)))), 1)
self.assertNotEqual(len(set(map(id, list(cwr('abcde', 3))))), 1)
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_permutations(self):
self.assertRaises(TypeError, permutations) # too few arguments
self.assertRaises(TypeError, permutations, 'abc', 2, 1) # too many arguments
@ -438,16 +446,19 @@ class TestBasicOps(unittest.TestCase):
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
self.pickletest(proto, permutations(values, r)) # test pickling
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
@support.bigaddrspacetest
def test_permutations_overflow(self):
with self.assertRaises((OverflowError, MemoryError)):
permutations("A", 2**30)
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
@support.impl_detail("tuple reuse is specific to CPython")
def test_permutations_tuple_reuse(self):
self.assertEqual(len(set(map(id, permutations('abcde', 3)))), 1)
self.assertNotEqual(len(set(map(id, list(permutations('abcde', 3))))), 1)
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_combinatorics(self):
# Test relationships between product(), permutations(),
# combinations() and combinations_with_replacement().
@ -1508,6 +1519,7 @@ class TestExamples(unittest.TestCase):
self.assertEqual(list(combinations(range(4), 3)),
[(0,1,2), (0,1,3), (0,2,3), (1,2,3)])
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_combinations_with_replacement(self):
self.assertEqual(list(combinations_with_replacement('ABC', 2)),
[('A','A'), ('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')])
@ -2023,6 +2035,7 @@ class RegressionTests(unittest.TestCase):
self.assertRaises(AssertionError, list, cycle(gen1()))
self.assertEqual(hist, [0,1])
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_long_chain_of_empty_iterables(self):
# Make sure itertools.chain doesn't run into recursion limits when
# dealing with long chains of empty iterables. Even with a high
@ -2082,12 +2095,14 @@ class SizeofTest(unittest.TestCase):
check(product('ab', '12'), basesize + 2 * self.ssize_t)
check(product(*(('abc',) * 10)), basesize + 10 * self.ssize_t)
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_combinations_sizeof(self):
basesize = support.calcobjsize('3Pni')
check = self.check_sizeof
check(combinations('abcd', 3), basesize + 3 * self.ssize_t)
check(combinations(range(10), 4), basesize + 4 * self.ssize_t)
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_combinations_with_replacement_sizeof(self):
cwr = combinations_with_replacement
basesize = support.calcobjsize('3Pni')
@ -2095,6 +2110,7 @@ class SizeofTest(unittest.TestCase):
check(cwr('abcd', 3), basesize + 3 * self.ssize_t)
check(cwr(range(10), 4), basesize + 4 * self.ssize_t)
@unittest.skipIf(sys.platform == 'cosmo', 'exceeds cpu quota')
def test_permutations_sizeof(self):
basesize = support.calcobjsize('4Pni')
check = self.check_sizeof

1
third_party/python/Lib/test/test_lzma.py vendored
View file

@ -7,6 +7,7 @@ import random
import sys
from test import support
import unittest
from encodings import utf_16_le
from test.support import (
_4G, TESTFN, import_module, bigmemtest, run_unittest, unlink

3
third_party/python/Lib/test/test_marshal.py vendored
View file

@ -12,6 +12,9 @@ try:
except ImportError:
_testcapi = None
if __name__ == 'PYOBJ.COM':
import _testcapi
class HelperMixin:
def helper(self, sample, *extra):
new = marshal.loads(marshal.dumps(sample, *extra))

10
third_party/python/Lib/test/test_math.py vendored
View file

@ -22,14 +22,8 @@ FLOAT_MAX = sys.float_info.max
x, y = 1e16, 2.9999 # use temporary values to defeat peephole optimizer
HAVE_DOUBLE_ROUNDING = (x + y == 1e16 + 4)
# locate file with test values
if __name__ == '__main__':
file = sys.argv[0]
else:
file = __file__
test_dir = os.path.dirname(file) or os.curdir
math_testcases = os.path.join(test_dir, 'math_testcases.txt')
test_file = os.path.join(test_dir, 'cmath_testcases.txt')
math_testcases = '/zip/.python/test/math_testcases.txt'
test_file = '/zip/.python/test/cmath_testcases.txt'
def to_ulps(x):

1
third_party/python/Lib/test/test_mmap.py vendored
View file

@ -10,6 +10,7 @@ import weakref
# Skip test if we can't import mmap.
mmap = import_module('mmap')
if __name__ == 'PYOBJ.COM': import mmap
PAGESIZE = mmap.PAGESIZE

74
third_party/python/Lib/test/test_robotparser.py vendored
View file

@ -285,79 +285,5 @@ class RobotHandler(BaseHTTPRequestHandler):
def log_message(self, format, *args):
pass
@unittest.skipUnless(threading, 'threading required for this test')
class PasswordProtectedSiteTestCase(unittest.TestCase):
def setUp(self):
self.server = HTTPServer((support.HOST, 0), RobotHandler)
self.t = threading.Thread(
name='HTTPServer serving',
target=self.server.serve_forever,
# Short poll interval to make the test finish quickly.
# Time between requests is short enough that we won't wake
# up spuriously too many times.
kwargs={'poll_interval':0.01})
self.t.daemon = True # In case this function raises.
self.t.start()
def tearDown(self):
self.server.shutdown()
self.t.join()
self.server.server_close()
@support.reap_threads
def testPasswordProtectedSite(self):
addr = self.server.server_address
url = 'http://' + support.HOST + ':' + str(addr[1])
robots_url = url + "/robots.txt"
parser = urllib.robotparser.RobotFileParser()
parser.set_url(url)
parser.read()
self.assertFalse(parser.can_fetch("*", robots_url))
class NetworkTestCase(unittest.TestCase):
base_url = 'http://www.pythontest.net/'
robots_txt = '{}elsewhere/robots.txt'.format(base_url)
@classmethod
def setUpClass(cls):
support.requires('network')
with support.transient_internet(cls.base_url):
cls.parser = urllib.robotparser.RobotFileParser(cls.robots_txt)
cls.parser.read()
def url(self, path):
return '{}{}{}'.format(
self.base_url, path, '/' if not os.path.splitext(path)[1] else ''
)
def test_basic(self):
self.assertFalse(self.parser.disallow_all)
self.assertFalse(self.parser.allow_all)
self.assertGreater(self.parser.mtime(), 0)
self.assertFalse(self.parser.crawl_delay('*'))
self.assertFalse(self.parser.request_rate('*'))
def test_can_fetch(self):
self.assertTrue(self.parser.can_fetch('*', self.url('elsewhere')))
self.assertFalse(self.parser.can_fetch('Nutch', self.base_url))
self.assertFalse(self.parser.can_fetch('Nutch', self.url('brian')))
self.assertFalse(self.parser.can_fetch('Nutch', self.url('webstats')))
self.assertFalse(self.parser.can_fetch('*', self.url('webstats')))
self.assertTrue(self.parser.can_fetch('*', self.base_url))
def test_read_404(self):
parser = urllib.robotparser.RobotFileParser(self.url('i-robot.txt'))
parser.read()
self.assertTrue(parser.allow_all)
self.assertFalse(parser.disallow_all)
self.assertEqual(parser.mtime(), 0)
self.assertIsNone(parser.crawl_delay('*'))
self.assertIsNone(parser.request_rate('*'))
if __name__=='__main__':
unittest.main()

14
third_party/python/Lib/test/test_sax.py vendored
View file

@ -24,8 +24,18 @@ from urllib.error import URLError
from test import support
from test.support import findfile, run_unittest, TESTFN
TEST_XMLFILE = findfile("test.xml", subdir="xmltestdata")
TEST_XMLFILE_OUT = findfile("test.xml.out", subdir="xmltestdata")
from encodings import (
utf_8_sig,
utf_16,
utf_16_be,
utf_16_le,
utf_32,
utf_32_be,
utf_32_le,
)
TEST_XMLFILE = "/zip/.python/test/xmltestdata/test.xml"
TEST_XMLFILE_OUT = "/zip/.python/test/xmltestdata/test.xml.out"
try:
TEST_XMLFILE.encode("utf-8")
TEST_XMLFILE_OUT.encode("utf-8")

1
third_party/python/Lib/test/test_source_encoding.py vendored
View file

@ -7,6 +7,7 @@ import os
import sys
import subprocess
import tempfile
from encodings import cp1252
class MiscSourceEncodingTest(unittest.TestCase):

10
third_party/python/Lib/test/test_stat.py vendored
View file

@ -6,6 +6,9 @@ from test.support import TESTFN, import_fresh_module
c_stat = import_fresh_module('stat', fresh=['_stat'])
py_stat = import_fresh_module('stat', blocked=['_stat'])
assert c_stat
assert py_stat
class TestFilemode:
statmod = None
@ -85,9 +88,10 @@ class TestFilemode:
def get_mode(self, fname=TESTFN, lstat=True):
if lstat:
st_mode = os.lstat(fname).st_mode
st_mode = os.lstat(fname).st_mode
else:
st_mode = os.stat(fname).st_mode
print('ugh',self.statmod)
modestr = self.statmod.filemode(st_mode)
return st_mode, modestr
@ -232,3 +236,7 @@ class TestFilemodePyStat(TestFilemode, unittest.TestCase):
if __name__ == '__main__':
unittest.main()
if __name__ == 'PYOBJ.COM':
import stat
import _stat

1
third_party/python/Lib/test/test_tempfile.py vendored
View file

@ -13,6 +13,7 @@ from unittest import mock
import unittest
from test import support
from encodings import utf_16
from test.support import script_helper

4
third_party/python/Lib/test/test_typing.py vendored
View file

@ -29,6 +29,10 @@ try:
except ImportError:
import collections as collections_abc # Fallback for PY3.2.
if __name__ == 'PYOBJ.COM':
import test.ann_module
import test.ann_module2
import test.ann_module3
try:
import mod_generics_cache

16
third_party/python/Lib/test/test_utf8source.py vendored
View file

@ -14,14 +14,14 @@ class PEP3120Test(unittest.TestCase):
b'\\\xd0\x9f'
)
def test_badsyntax(self):
try:
import test.badsyntax_pep3120
except SyntaxError as msg:
msg = str(msg).lower()
self.assertTrue('utf-8' in msg)
else:
self.fail("expected exception didn't occur")
# def test_badsyntax(self):
# try:
# import test.badsyntax_pep3120
# except SyntaxError as msg:
# msg = str(msg).lower()
# self.assertTrue('utf-8' in msg)
# else:
# self.fail("expected exception didn't occur")
class BuiltinCompileTests(unittest.TestCase):

1
third_party/python/Lib/test/test_xml_etree.py vendored
View file

@ -16,6 +16,7 @@ import unittest
import warnings
import weakref
from encodings import utf_16
from itertools import product
from test import support
from test.support import TESTFN, findfile, import_fresh_module, gc_collect, swap_attr

5
third_party/python/Lib/test/test_zlib.py vendored
View file

@ -4,10 +4,9 @@ import binascii
import pickle
import random
import sys
import zlib
from test.support import bigmemtest, _1G, _4G
zlib = support.import_module('zlib')
requires_Compress_copy = unittest.skipUnless(
hasattr(zlib.compressobj(), "copy"),
'requires Compress.copy()')
@ -710,6 +709,8 @@ class CompressObjectTestCase(BaseCompressTestCase, unittest.TestCase):
@bigmemtest(size=_1G + 1024 * 1024, memuse=3)
def test_big_compress_buffer(self, size):
import tracemalloc
tracemalloc.start(20)
c = zlib.compressobj(1)
compress = lambda s: c.compress(s) + c.flush()
self.check_big_compress_buffer(size, compress)

11
third_party/python/Lib/unittest/runner.py vendored
View file

@ -1,5 +1,6 @@
"""Running tests"""
import os
import sys
import time
import warnings
@ -38,7 +39,7 @@ class TextTestResult(result.TestResult):
super(TextTestResult, self).__init__(stream, descriptions, verbosity)
self.stream = stream
self.showAll = verbosity > 1
self.dots = verbosity == 1
self.dots = verbosity == 1 and os.getenv('MAKEFLAGS') is None
self.descriptions = descriptions
def getDescription(self, test):
@ -183,8 +184,12 @@ class TextTestRunner(object):
result.printErrors()
# [jart local modification]
# [print nothing on success in quiet mode]
if not self.verbosity and result.wasSuccessful():
# print nothing on success, if
# 1. running in quiet mode, or
# 2. running under gnu make
if ((not self.verbosity or
os.getenv('MAKEFLAGS') is not None) and
result.wasSuccessful()):
return result
if hasattr(result, 'separator2'):

4
third_party/python/Lib/warnings.py vendored
View file

@ -493,13 +493,13 @@ except ImportError:
filters = []
defaultaction = "default"
onceregistry = {}
_filters_version = 1
def _filters_mutated():
global _filters_version
_filters_version += 1
if __name__ == 'PYOBJ.COM':
import _warnings
# Module initialization
_processoptions(sys.warnoptions)