LOLCATS

: /opt/alt/python312/lib64/python3.12/test/ [ drwxr-xr-x ]

Information Server

NONE

Command ON Config Searcher Create RDP Find Modified Time Find File Get Tools GSocket Jumping Lock File Mass Deface Mass Delete Mass Chmod Mass Change Date Port Scan Reverse Shell Upload Zone-H

: test_asyncgen.py

import inspect
import types
import unittest
import contextlib

from test.support.import_helper import import_module
from test.support import gc_collect, requires_working_socket
asyncio = import_module("asyncio")

requires_working_socket(module=True)

_no_default = object()

class AwaitException(Exception):
    pass

@types.coroutine
def awaitable(*, throw=False):
    if throw:
        yield ('throw',)
    else:
        yield ('result',)

def run_until_complete(coro):
    exc = False
    while True:
        try:
            if exc:
                exc = False
                fut = coro.throw(AwaitException)
            else:
                fut = coro.send(None)
        except StopIteration as ex:
            return ex.args[0]

if fut == ('throw',):
            exc = True

def to_list(gen):
    async def iterate():
        res = []
        async for i in gen:
            res.append(i)
        return res

return run_until_complete(iterate())

def py_anext(iterator, default=_no_default):
    """Pure-Python implementation of anext() for testing purposes.

Closely matches the builtin anext() C implementation.
    Can be used to compare the built-in implementation of the inner
    coroutines machinery to C-implementation of __anext__() and send()
    or throw() on the returned generator.
    """

try:
        __anext__ = type(iterator).__anext__
    except AttributeError:
        raise TypeError(f'{iterator!r} is not an async iterator')

if default is _no_default:
        return __anext__(iterator)

async def anext_impl():
        try:
            # The C code is way more low-level than this, as it implements
            # all methods of the iterator protocol. In this implementation
            # we're relying on higher-level coroutine concepts, but that's
            # exactly what we want -- crosstest pure-Python high-level
            # implementation and low-level C anext() iterators.
            return await __anext__(iterator)
        except StopAsyncIteration:
            return default

return anext_impl()

class AsyncGenSyntaxTest(unittest.TestCase):

def test_async_gen_syntax_01(self):
        code = '''async def foo():
            await abc
            yield from 123
        '''

with self.assertRaisesRegex(SyntaxError, 'yield from.*inside async'):
            exec(code, {}, {})

def test_async_gen_syntax_02(self):
        code = '''async def foo():
            yield from 123
        '''

with self.assertRaisesRegex(SyntaxError, 'yield from.*inside async'):
            exec(code, {}, {})

def test_async_gen_syntax_03(self):
        code = '''async def foo():
            await abc
            yield
            return 123
        '''

with self.assertRaisesRegex(SyntaxError, 'return.*value.*async gen'):
            exec(code, {}, {})

def test_async_gen_syntax_04(self):
        code = '''async def foo():
            yield
            return 123
        '''

with self.assertRaisesRegex(SyntaxError, 'return.*value.*async gen'):
            exec(code, {}, {})

def test_async_gen_syntax_05(self):
        code = '''async def foo():
            if 0:
                yield
            return 12
        '''

with self.assertRaisesRegex(SyntaxError, 'return.*value.*async gen'):
            exec(code, {}, {})

class AsyncGenTest(unittest.TestCase):

def compare_generators(self, sync_gen, async_gen):
        def sync_iterate(g):
            res = []
            while True:
                try:
                    res.append(g.__next__())
                except StopIteration:
                    res.append('STOP')
                    break
                except Exception as ex:
                    res.append(str(type(ex)))
            return res

def async_iterate(g):
            res = []
            while True:
                an = g.__anext__()
                try:
                    while True:
                        try:
                            an.__next__()
                        except StopIteration as ex:
                            if ex.args:
                                res.append(ex.args[0])
                                break
                            else:
                                res.append('EMPTY StopIteration')
                                break
                        except StopAsyncIteration:
                            raise
                        except Exception as ex:
                            res.append(str(type(ex)))
                            break
                except StopAsyncIteration:
                    res.append('STOP')
                    break
            return res

sync_gen_result = sync_iterate(sync_gen)
        async_gen_result = async_iterate(async_gen)
        self.assertEqual(sync_gen_result, async_gen_result)
        return async_gen_result

def test_async_gen_iteration_01(self):
        async def gen():
            await awaitable()
            a = yield 123
            self.assertIs(a, None)
            await awaitable()
            yield 456
            await awaitable()
            yield 789

self.assertEqual(to_list(gen()), [123, 456, 789])

def test_async_gen_iteration_02(self):
        async def gen():
            await awaitable()
            yield 123
            await awaitable()

g = gen()
        ai = g.__aiter__()

an = ai.__anext__()
        self.assertEqual(an.__next__(), ('result',))

try:
            an.__next__()
        except StopIteration as ex:
            self.assertEqual(ex.args[0], 123)
        else:
            self.fail('StopIteration was not raised')

an = ai.__anext__()
        self.assertEqual(an.__next__(), ('result',))

try:
            an.__next__()
        except StopAsyncIteration as ex:
            self.assertFalse(ex.args)
        else:
            self.fail('StopAsyncIteration was not raised')

def test_async_gen_exception_03(self):
        async def gen():
            await awaitable()
            yield 123
            await awaitable(throw=True)
            yield 456

with self.assertRaises(AwaitException):
            to_list(gen())

def test_async_gen_exception_04(self):
        async def gen():
            await awaitable()
            yield 123
            1 / 0

g = gen()
        ai = g.__aiter__()
        an = ai.__anext__()
        self.assertEqual(an.__next__(), ('result',))

try:
            an.__next__()
        except StopIteration as ex:
            self.assertEqual(ex.args[0], 123)
        else:
            self.fail('StopIteration was not raised')

with self.assertRaises(ZeroDivisionError):
            ai.__anext__().__next__()

def test_async_gen_exception_05(self):
        async def gen():
            yield 123
            raise StopAsyncIteration

with self.assertRaisesRegex(RuntimeError,
                                    'async generator.*StopAsyncIteration'):
            to_list(gen())

def test_async_gen_exception_06(self):
        async def gen():
            yield 123
            raise StopIteration

with self.assertRaisesRegex(RuntimeError,
                                    'async generator.*StopIteration'):
            to_list(gen())

def test_async_gen_exception_07(self):
        def sync_gen():
            try:
                yield 1
                1 / 0
            finally:
                yield 2
                yield 3

yield 100

async def async_gen():
            try:
                yield 1
                1 / 0
            finally:
                yield 2
                yield 3

yield 100

self.compare_generators(sync_gen(), async_gen())

def test_async_gen_exception_08(self):
        def sync_gen():
            try:
                yield 1
            finally:
                yield 2
                1 / 0
                yield 3

yield 100

async def async_gen():
            try:
                yield 1
                await awaitable()
            finally:
                await awaitable()
                yield 2
                1 / 0
                yield 3

yield 100

self.compare_generators(sync_gen(), async_gen())

def test_async_gen_exception_09(self):
        def sync_gen():
            try:
                yield 1
                1 / 0
            finally:
                yield 2
                yield 3

yield 100

async def async_gen():
            try:
                await awaitable()
                yield 1
                1 / 0
            finally:
                yield 2
                await awaitable()
                yield 3

yield 100

self.compare_generators(sync_gen(), async_gen())

def test_async_gen_exception_10(self):
        async def gen():
            yield 123
        with self.assertRaisesRegex(TypeError,
                                    "non-None value .* async generator"):
            gen().__anext__().send(100)

def test_async_gen_exception_11(self):
        def sync_gen():
            yield 10
            yield 20

def sync_gen_wrapper():
            yield 1
            sg = sync_gen()
            sg.send(None)
            try:
                sg.throw(GeneratorExit())
            except GeneratorExit:
                yield 2
            yield 3

async def async_gen():
            yield 10
            yield 20

async def async_gen_wrapper():
            yield 1
            asg = async_gen()
            await asg.asend(None)
            try:
                await asg.athrow(GeneratorExit())
            except GeneratorExit:
                yield 2
            yield 3

self.compare_generators(sync_gen_wrapper(), async_gen_wrapper())

def test_async_gen_exception_12(self):
        async def gen():
            await anext(me)
            yield 123

me = gen()
        ai = me.__aiter__()
        an = ai.__anext__()

with self.assertRaisesRegex(RuntimeError,
                r'anext\(\): asynchronous generator is already running'):
            an.__next__()

with self.assertRaisesRegex(RuntimeError,
                r"cannot reuse already awaited __anext__\(\)/asend\(\)"):
            an.send(None)

def test_async_gen_asend_throw_concurrent_with_send(self):
        import types

@types.coroutine
        def _async_yield(v):
            return (yield v)

class MyExc(Exception):
            pass

async def agenfn():
            while True:
                try:
                    await _async_yield(None)
                except MyExc:
                    pass
            return
            yield

agen = agenfn()
        gen = agen.asend(None)
        gen.send(None)
        gen2 = agen.asend(None)

with self.assertRaisesRegex(RuntimeError,
                r'anext\(\): asynchronous generator is already running'):
            gen2.throw(MyExc)

with self.assertRaisesRegex(RuntimeError,
                r"cannot reuse already awaited __anext__\(\)/asend\(\)"):
            gen2.send(None)

def test_async_gen_athrow_throw_concurrent_with_send(self):
        import types

@types.coroutine
        def _async_yield(v):
            return (yield v)

class MyExc(Exception):
            pass

agen = agenfn()
        gen = agen.asend(None)
        gen.send(None)
        gen2 = agen.athrow(MyExc)

with self.assertRaisesRegex(RuntimeError,
                r'athrow\(\): asynchronous generator is already running'):
            gen2.throw(MyExc)

with self.assertRaisesRegex(RuntimeError,
                r"cannot reuse already awaited aclose\(\)/athrow\(\)"):
            gen2.send(None)

def test_async_gen_asend_throw_concurrent_with_throw(self):
        import types

@types.coroutine
        def _async_yield(v):
            return (yield v)

class MyExc(Exception):
            pass

async def agenfn():
            try:
                yield
            except MyExc:
                pass
            while True:
                try:
                    await _async_yield(None)
                except MyExc:
                    pass

agen = agenfn()
        with self.assertRaises(StopIteration):
            agen.asend(None).send(None)

gen = agen.athrow(MyExc)
        gen.throw(MyExc)
        gen2 = agen.asend(MyExc)

with self.assertRaisesRegex(RuntimeError,
                r'anext\(\): asynchronous generator is already running'):
            gen2.throw(MyExc)

with self.assertRaisesRegex(RuntimeError,
                r"cannot reuse already awaited __anext__\(\)/asend\(\)"):
            gen2.send(None)

def test_async_gen_athrow_throw_concurrent_with_throw(self):
        import types

@types.coroutine
        def _async_yield(v):
            return (yield v)

class MyExc(Exception):
            pass

agen = agenfn()
        with self.assertRaises(StopIteration):
            agen.asend(None).send(None)

gen = agen.athrow(MyExc)
        gen.throw(MyExc)
        gen2 = agen.athrow(None)

with self.assertRaisesRegex(RuntimeError,
                r'athrow\(\): asynchronous generator is already running'):
            gen2.throw(MyExc)

with self.assertRaisesRegex(RuntimeError,
                r"cannot reuse already awaited aclose\(\)/athrow\(\)"):
            gen2.send(None)

def test_async_gen_3_arg_deprecation_warning(self):
        async def gen():
            yield 123

with self.assertWarns(DeprecationWarning):
            x = gen().athrow(GeneratorExit, GeneratorExit(), None)
        with self.assertRaises(GeneratorExit):
            x.send(None)
            del x
            gc_collect()

def test_async_gen_api_01(self):
        async def gen():
            yield 123

g = gen()

self.assertEqual(g.__name__, 'gen')
        g.__name__ = '123'
        self.assertEqual(g.__name__, '123')

self.assertIn('.gen', g.__qualname__)
        g.__qualname__ = '123'
        self.assertEqual(g.__qualname__, '123')

self.assertIsNone(g.ag_await)
        self.assertIsInstance(g.ag_frame, types.FrameType)
        self.assertFalse(g.ag_running)
        self.assertIsInstance(g.ag_code, types.CodeType)

self.assertTrue(inspect.isawaitable(g.aclose()))

class AsyncGenAsyncioTest(unittest.TestCase):

def setUp(self):
        self.loop = asyncio.new_event_loop()
        asyncio.set_event_loop(None)

def tearDown(self):
        self.loop.close()
        self.loop = None
        asyncio.set_event_loop_policy(None)

def check_async_iterator_anext(self, ait_class):
        with self.subTest(anext="pure-Python"):
            self._check_async_iterator_anext(ait_class, py_anext)
        with self.subTest(anext="builtin"):
            self._check_async_iterator_anext(ait_class, anext)

def _check_async_iterator_anext(self, ait_class, anext):
        g = ait_class()
        async def consume():
            results = []
            results.append(await anext(g))
            results.append(await anext(g))
            results.append(await anext(g, 'buckle my shoe'))
            return results
        res = self.loop.run_until_complete(consume())
        self.assertEqual(res, [1, 2, 'buckle my shoe'])
        with self.assertRaises(StopAsyncIteration):
            self.loop.run_until_complete(consume())

async def test_2():
            g1 = ait_class()
            self.assertEqual(await anext(g1), 1)
            self.assertEqual(await anext(g1), 2)
            with self.assertRaises(StopAsyncIteration):
                await anext(g1)
            with self.assertRaises(StopAsyncIteration):
                await anext(g1)

g2 = ait_class()
            self.assertEqual(await anext(g2, "default"), 1)
            self.assertEqual(await anext(g2, "default"), 2)
            self.assertEqual(await anext(g2, "default"), "default")
            self.assertEqual(await anext(g2, "default"), "default")

return "completed"

result = self.loop.run_until_complete(test_2())
        self.assertEqual(result, "completed")

def test_send():
            p = ait_class()
            obj = anext(p, "completed")
            with self.assertRaises(StopIteration):
                with contextlib.closing(obj.__await__()) as g:
                    g.send(None)

test_send()

async def test_throw():
            p = ait_class()
            obj = anext(p, "completed")
            self.assertRaises(SyntaxError, obj.throw, SyntaxError)
            return "completed"

result = self.loop.run_until_complete(test_throw())
        self.assertEqual(result, "completed")

def test_async_generator_anext(self):
        async def agen():
            yield 1
            yield 2
        self.check_async_iterator_anext(agen)

def test_python_async_iterator_anext(self):
        class MyAsyncIter:
            """Asynchronously yield 1, then 2."""
            def __init__(self):
                self.yielded = 0
            def __aiter__(self):
                return self
            async def __anext__(self):
                if self.yielded >= 2:
                    raise StopAsyncIteration()
                else:
                    self.yielded += 1
                    return self.yielded
        self.check_async_iterator_anext(MyAsyncIter)

def test_python_async_iterator_types_coroutine_anext(self):
        import types
        class MyAsyncIterWithTypesCoro:
            """Asynchronously yield 1, then 2."""
            def __init__(self):
                self.yielded = 0
            def __aiter__(self):
                return self
            @types.coroutine
            def __anext__(self):
                if False:
                    yield "this is a generator-based coroutine"
                if self.yielded >= 2:
                    raise StopAsyncIteration()
                else:
                    self.yielded += 1
                    return self.yielded
        self.check_async_iterator_anext(MyAsyncIterWithTypesCoro)

def test_async_gen_aiter(self):
        async def gen():
            yield 1
            yield 2
        g = gen()
        async def consume():
            return [i async for i in aiter(g)]
        res = self.loop.run_until_complete(consume())
        self.assertEqual(res, [1, 2])

def test_async_gen_aiter_class(self):
        results = []
        class Gen:
            async def __aiter__(self):
                yield 1
                yield 2
        g = Gen()
        async def consume():
            ait = aiter(g)
            while True:
                try:
                    results.append(await anext(ait))
                except StopAsyncIteration:
                    break
        self.loop.run_until_complete(consume())
        self.assertEqual(results, [1, 2])

def test_aiter_idempotent(self):
        async def gen():
            yield 1
        applied_once = aiter(gen())
        applied_twice = aiter(applied_once)
        self.assertIs(applied_once, applied_twice)

def test_anext_bad_args(self):
        async def gen():
            yield 1
        async def call_with_too_few_args():
            await anext()
        async def call_with_too_many_args():
            await anext(gen(), 1, 3)
        async def call_with_wrong_type_args():
            await anext(1, gen())
        async def call_with_kwarg():
            await anext(aiterator=gen())
        with self.assertRaises(TypeError):
            self.loop.run_until_complete(call_with_too_few_args())
        with self.assertRaises(TypeError):
            self.loop.run_until_complete(call_with_too_many_args())
        with self.assertRaises(TypeError):
            self.loop.run_until_complete(call_with_wrong_type_args())
        with self.assertRaises(TypeError):
            self.loop.run_until_complete(call_with_kwarg())

def test_anext_bad_await(self):
        async def bad_awaitable():
            class BadAwaitable:
                def __await__(self):
                    return 42
            class MyAsyncIter:
                def __aiter__(self):
                    return self
                def __anext__(self):
                    return BadAwaitable()
            regex = r"__await__.*iterator"
            awaitable = anext(MyAsyncIter(), "default")
            with self.assertRaisesRegex(TypeError, regex):
                await awaitable
            awaitable = anext(MyAsyncIter())
            with self.assertRaisesRegex(TypeError, regex):
                await awaitable
            return "completed"
        result = self.loop.run_until_complete(bad_awaitable())
        self.assertEqual(result, "completed")

async def check_anext_returning_iterator(self, aiter_class):
        awaitable = anext(aiter_class(), "default")
        with self.assertRaises(TypeError):
            await awaitable
        awaitable = anext(aiter_class())
        with self.assertRaises(TypeError):
            await awaitable
        return "completed"

def test_anext_return_iterator(self):
        class WithIterAnext:
            def __aiter__(self):
                return self
            def __anext__(self):
                return iter("abc")
        result = self.loop.run_until_complete(self.check_anext_returning_iterator(WithIterAnext))
        self.assertEqual(result, "completed")

def test_anext_return_generator(self):
        class WithGenAnext:
            def __aiter__(self):
                return self
            def __anext__(self):
                yield
        result = self.loop.run_until_complete(self.check_anext_returning_iterator(WithGenAnext))
        self.assertEqual(result, "completed")

def test_anext_await_raises(self):
        class RaisingAwaitable:
            def __await__(self):
                raise ZeroDivisionError()
                yield
        class WithRaisingAwaitableAnext:
            def __aiter__(self):
                return self
            def __anext__(self):
                return RaisingAwaitable()
        async def do_test():
            awaitable = anext(WithRaisingAwaitableAnext())
            with self.assertRaises(ZeroDivisionError):
                await awaitable
            awaitable = anext(WithRaisingAwaitableAnext(), "default")
            with self.assertRaises(ZeroDivisionError):
                await awaitable
            return "completed"
        result = self.loop.run_until_complete(do_test())
        self.assertEqual(result, "completed")

def test_anext_iter(self):
        @types.coroutine
        def _async_yield(v):
            return (yield v)

class MyError(Exception):
            pass

async def agenfn():
            try:
                await _async_yield(1)
            except MyError:
                await _async_yield(2)
            return
            yield

def test1(anext):
            agen = agenfn()
            with contextlib.closing(anext(agen, "default").__await__()) as g:
                self.assertEqual(g.send(None), 1)
                self.assertEqual(g.throw(MyError()), 2)
                try:
                    g.send(None)
                except StopIteration as e:
                    err = e
                else:
                    self.fail('StopIteration was not raised')
                self.assertEqual(err.value, "default")

def test2(anext):
            agen = agenfn()
            with contextlib.closing(anext(agen, "default").__await__()) as g:
                self.assertEqual(g.send(None), 1)
                self.assertEqual(g.throw(MyError()), 2)
                with self.assertRaises(MyError):
                    g.throw(MyError())

def test3(anext):
            agen = agenfn()
            with contextlib.closing(anext(agen, "default").__await__()) as g:
                self.assertEqual(g.send(None), 1)
                g.close()
                with self.assertRaisesRegex(RuntimeError, 'cannot reuse'):
                    self.assertEqual(g.send(None), 1)

def test4(anext):
            @types.coroutine
            def _async_yield(v):
                yield v * 10
                return (yield (v * 10 + 1))

async def agenfn():
                try:
                    await _async_yield(1)
                except MyError:
                    await _async_yield(2)
                return
                yield

agen = agenfn()
            with contextlib.closing(anext(agen, "default").__await__()) as g:
                self.assertEqual(g.send(None), 10)
                self.assertEqual(g.throw(MyError()), 20)
                with self.assertRaisesRegex(MyError, 'val'):
                    g.throw(MyError('val'))

def test5(anext):
            @types.coroutine
            def _async_yield(v):
                yield v * 10
                return (yield (v * 10 + 1))

async def agenfn():
                try:
                    await _async_yield(1)
                except MyError:
                    return
                yield 'aaa'

agen = agenfn()
            with contextlib.closing(anext(agen, "default").__await__()) as g:
                self.assertEqual(g.send(None), 10)
                with self.assertRaisesRegex(StopIteration, 'default'):
                    g.throw(MyError())

def test6(anext):
            @types.coroutine
            def _async_yield(v):
                yield v * 10
                return (yield (v * 10 + 1))

async def agenfn():
                await _async_yield(1)
                yield 'aaa'

agen = agenfn()
            with contextlib.closing(anext(agen, "default").__await__()) as g:
                with self.assertRaises(MyError):
                    g.throw(MyError())

def run_test(test):
            with self.subTest('pure-Python anext()'):
                test(py_anext)
            with self.subTest('builtin anext()'):
                test(anext)

run_test(test1)
        run_test(test2)
        run_test(test3)
        run_test(test4)
        run_test(test5)
        run_test(test6)

def test_aiter_bad_args(self):
        async def gen():
            yield 1
        async def call_with_too_few_args():
            await aiter()
        async def call_with_too_many_args():
            await aiter(gen(), 1)
        async def call_with_wrong_type_arg():
            await aiter(1)
        with self.assertRaises(TypeError):
            self.loop.run_until_complete(call_with_too_few_args())
        with self.assertRaises(TypeError):
            self.loop.run_until_complete(call_with_too_many_args())
        with self.assertRaises(TypeError):
            self.loop.run_until_complete(call_with_wrong_type_arg())

async def to_list(self, gen):
        res = []
        async for i in gen:
            res.append(i)
        return res

def test_async_gen_asyncio_01(self):
        async def gen():
            yield 1
            await asyncio.sleep(0.01)
            yield 2
            await asyncio.sleep(0.01)
            return
            yield 3

res = self.loop.run_until_complete(self.to_list(gen()))
        self.assertEqual(res, [1, 2])

def test_async_gen_asyncio_02(self):
        async def gen():
            yield 1
            await asyncio.sleep(0.01)
            yield 2
            1 / 0
            yield 3

with self.assertRaises(ZeroDivisionError):
            self.loop.run_until_complete(self.to_list(gen()))

def test_async_gen_asyncio_03(self):
        loop = self.loop

class Gen:
            async def __aiter__(self):
                yield 1
                await asyncio.sleep(0.01)
                yield 2

res = loop.run_until_complete(self.to_list(Gen()))
        self.assertEqual(res, [1, 2])

def test_async_gen_asyncio_anext_04(self):
        async def foo():
            yield 1
            await asyncio.sleep(0.01)
            try:
                yield 2
                yield 3
            except ZeroDivisionError:
                yield 1000
            await asyncio.sleep(0.01)
            yield 4

async def run1():
            it = foo().__aiter__()

self.assertEqual(await it.__anext__(), 1)
            self.assertEqual(await it.__anext__(), 2)
            self.assertEqual(await it.__anext__(), 3)
            self.assertEqual(await it.__anext__(), 4)
            with self.assertRaises(StopAsyncIteration):
                await it.__anext__()
            with self.assertRaises(StopAsyncIteration):
                await it.__anext__()

async def run2():
            it = foo().__aiter__()

self.assertEqual(await it.__anext__(), 1)
            self.assertEqual(await it.__anext__(), 2)
            try:
                it.__anext__().throw(ZeroDivisionError)
            except StopIteration as ex:
                self.assertEqual(ex.args[0], 1000)
            else:
                self.fail('StopIteration was not raised')
            self.assertEqual(await it.__anext__(), 4)
            with self.assertRaises(StopAsyncIteration):
                await it.__anext__()

self.loop.run_until_complete(run1())
        self.loop.run_until_complete(run2())

def test_async_gen_asyncio_anext_05(self):
        async def foo():
            v = yield 1
            v = yield v
            yield v * 100

async def run():
            it = foo().__aiter__()

try:
                it.__anext__().send(None)
            except StopIteration as ex:
                self.assertEqual(ex.args[0], 1)
            else:
                self.fail('StopIteration was not raised')

try:
                it.__anext__().send(10)
            except StopIteration as ex:
                self.assertEqual(ex.args[0], 10)
            else:
                self.fail('StopIteration was not raised')

try:
                it.__anext__().send(12)
            except StopIteration as ex:
                self.assertEqual(ex.args[0], 1200)
            else:
                self.fail('StopIteration was not raised')

with self.assertRaises(StopAsyncIteration):
                await it.__anext__()

self.loop.run_until_complete(run())

def test_async_gen_asyncio_anext_06(self):
        DONE = 0

# test synchronous generators
        def foo():
            try:
                yield
            except:
                pass
        g = foo()
        g.send(None)
        with self.assertRaises(StopIteration):
            g.send(None)

# now with asynchronous generators

async def gen():
            nonlocal DONE
            try:
                yield
            except:
                pass
            DONE = 1

async def run():
            nonlocal DONE
            g = gen()
            await g.asend(None)
            with self.assertRaises(StopAsyncIteration):
                await g.asend(None)
            DONE += 10

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 11)

def test_async_gen_asyncio_anext_tuple(self):
        async def foo():
            try:
                yield (1,)
            except ZeroDivisionError:
                yield (2,)

async def run():
            it = foo().__aiter__()

self.assertEqual(await it.__anext__(), (1,))
            with self.assertRaises(StopIteration) as cm:
                it.__anext__().throw(ZeroDivisionError)
            self.assertEqual(cm.exception.args[0], (2,))
            with self.assertRaises(StopAsyncIteration):
                await it.__anext__()

self.loop.run_until_complete(run())

def test_async_gen_asyncio_anext_tuple_no_exceptions(self):
        # StopAsyncIteration exceptions should be cleared.
        # See: https://github.com/python/cpython/issues/128078.

async def foo():
            if False:
                yield (1, 2)

async def run():
            it = foo().__aiter__()
            with self.assertRaises(StopAsyncIteration):
                await it.__anext__()
            res = await anext(it, ('a', 'b'))
            self.assertTupleEqual(res, ('a', 'b'))

self.loop.run_until_complete(run())

def test_sync_anext_raises_exception(self):
        # See: https://github.com/python/cpython/issues/131670
        msg = 'custom'
        for exc_type in [
            StopAsyncIteration,
            StopIteration,
            ValueError,
            Exception,
        ]:
            exc = exc_type(msg)
            with self.subTest(exc=exc):
                class A:
                    def __anext__(self):
                        raise exc

with self.assertRaisesRegex(exc_type, msg):
                    anext(A())
                with self.assertRaisesRegex(exc_type, msg):
                    anext(A(), 1)

def test_async_gen_asyncio_anext_stopiteration(self):
        async def foo():
            try:
                yield StopIteration(1)
            except ZeroDivisionError:
                yield StopIteration(3)

async def run():
            it = foo().__aiter__()

v = await it.__anext__()
            self.assertIsInstance(v, StopIteration)
            self.assertEqual(v.value, 1)
            with self.assertRaises(StopIteration) as cm:
                it.__anext__().throw(ZeroDivisionError)
            v = cm.exception.args[0]
            self.assertIsInstance(v, StopIteration)
            self.assertEqual(v.value, 3)
            with self.assertRaises(StopAsyncIteration):
                await it.__anext__()

self.loop.run_until_complete(run())

def test_async_gen_asyncio_aclose_06(self):
        async def foo():
            try:
                yield 1
                1 / 0
            finally:
                await asyncio.sleep(0.01)
                yield 12

async def run():
            gen = foo()
            it = gen.__aiter__()
            await it.__anext__()
            await gen.aclose()

with self.assertRaisesRegex(
                RuntimeError,
                "async generator ignored GeneratorExit"):
            self.loop.run_until_complete(run())

def test_async_gen_asyncio_aclose_07(self):
        DONE = 0

async def foo():
            nonlocal DONE
            try:
                yield 1
                1 / 0
            finally:
                await asyncio.sleep(0.01)
                await asyncio.sleep(0.01)
                DONE += 1
            DONE += 1000

async def run():
            gen = foo()
            it = gen.__aiter__()
            await it.__anext__()
            await gen.aclose()

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 1)

def test_async_gen_asyncio_aclose_08(self):
        DONE = 0

fut = asyncio.Future(loop=self.loop)

async def foo():
            nonlocal DONE
            try:
                yield 1
                await fut
                DONE += 1000
                yield 2
            finally:
                await asyncio.sleep(0.01)
                await asyncio.sleep(0.01)
                DONE += 1
            DONE += 1000

async def run():
            gen = foo()
            it = gen.__aiter__()
            self.assertEqual(await it.__anext__(), 1)
            await gen.aclose()

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 1)

# Silence ResourceWarnings
        fut.cancel()
        self.loop.run_until_complete(asyncio.sleep(0.01))

def test_async_gen_asyncio_gc_aclose_09(self):
        DONE = 0

async def gen():
            nonlocal DONE
            try:
                while True:
                    yield 1
            finally:
                await asyncio.sleep(0)
                DONE = 1

async def run():
            g = gen()
            await g.__anext__()
            await g.__anext__()
            del g
            gc_collect()  # For PyPy or other GCs.

# Starts running the aclose task
            await asyncio.sleep(0)
            # For asyncio.sleep(0) in finally block
            await asyncio.sleep(0)

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 1)

def test_async_gen_asyncio_aclose_10(self):
        DONE = 0

# test synchronous generators
        def foo():
            try:
                yield
            except:
                pass
        g = foo()
        g.send(None)
        g.close()

# now with asynchronous generators

async def gen():
            nonlocal DONE
            try:
                yield
            except:
                pass
            DONE = 1

async def run():
            nonlocal DONE
            g = gen()
            await g.asend(None)
            await g.aclose()
            DONE += 10

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 11)

def test_async_gen_asyncio_aclose_11(self):
        DONE = 0

# test synchronous generators
        def foo():
            try:
                yield
            except:
                pass
            yield
        g = foo()
        g.send(None)
        with self.assertRaisesRegex(RuntimeError, 'ignored GeneratorExit'):
            g.close()

# now with asynchronous generators

async def gen():
            nonlocal DONE
            try:
                yield
            except:
                pass
            yield
            DONE += 1

async def run():
            nonlocal DONE
            g = gen()
            await g.asend(None)
            with self.assertRaisesRegex(RuntimeError, 'ignored GeneratorExit'):
                await g.aclose()
            DONE += 10

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 10)

def test_async_gen_asyncio_aclose_12(self):
        DONE = 0

async def target():
            await asyncio.sleep(0.01)
            1 / 0

async def foo():
            nonlocal DONE
            task = asyncio.create_task(target())
            try:
                yield 1
            finally:
                try:
                    await task
                except ZeroDivisionError:
                    DONE = 1

async def run():
            gen = foo()
            it = gen.__aiter__()
            await it.__anext__()
            await gen.aclose()

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 1)

def test_async_gen_asyncio_asend_01(self):
        DONE = 0

# Sanity check:
        def sgen():
            v = yield 1
            yield v * 2
        sg = sgen()
        v = sg.send(None)
        self.assertEqual(v, 1)
        v = sg.send(100)
        self.assertEqual(v, 200)

async def gen():
            nonlocal DONE
            try:
                await asyncio.sleep(0.01)
                v = yield 1
                await asyncio.sleep(0.01)
                yield v * 2
                await asyncio.sleep(0.01)
                return
            finally:
                await asyncio.sleep(0.01)
                await asyncio.sleep(0.01)
                DONE = 1

async def run():
            g = gen()

v = await g.asend(None)
            self.assertEqual(v, 1)

v = await g.asend(100)
            self.assertEqual(v, 200)

with self.assertRaises(StopAsyncIteration):
                await g.asend(None)

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 1)

def test_async_gen_asyncio_asend_02(self):
        DONE = 0

async def sleep_n_crash(delay):
            await asyncio.sleep(delay)
            1 / 0

async def gen():
            nonlocal DONE
            try:
                await asyncio.sleep(0.01)
                v = yield 1
                await sleep_n_crash(0.01)
                DONE += 1000
                yield v * 2
            finally:
                await asyncio.sleep(0.01)
                await asyncio.sleep(0.01)
                DONE = 1

async def run():
            g = gen()

v = await g.asend(None)
            self.assertEqual(v, 1)

await g.asend(100)

with self.assertRaises(ZeroDivisionError):
            self.loop.run_until_complete(run())
        self.assertEqual(DONE, 1)

def test_async_gen_asyncio_asend_03(self):
        DONE = 0

async def sleep_n_crash(delay):
            fut = asyncio.ensure_future(asyncio.sleep(delay),
                                        loop=self.loop)
            self.loop.call_later(delay / 2, lambda: fut.cancel())
            return await fut

async def run():
            g = gen()

v = await g.asend(None)
            self.assertEqual(v, 1)

await g.asend(100)

with self.assertRaises(asyncio.CancelledError):
            self.loop.run_until_complete(run())
        self.assertEqual(DONE, 1)

def test_async_gen_asyncio_athrow_01(self):
        DONE = 0

class FooEr(Exception):
            pass

# Sanity check:
        def sgen():
            try:
                v = yield 1
            except FooEr:
                v = 1000
            yield v * 2
        sg = sgen()
        v = sg.send(None)
        self.assertEqual(v, 1)
        v = sg.throw(FooEr)
        self.assertEqual(v, 2000)
        with self.assertRaises(StopIteration):
            sg.send(None)

async def gen():
            nonlocal DONE
            try:
                await asyncio.sleep(0.01)
                try:
                    v = yield 1
                except FooEr:
                    v = 1000
                    await asyncio.sleep(0.01)
                yield v * 2
                await asyncio.sleep(0.01)
                # return
            finally:
                await asyncio.sleep(0.01)
                await asyncio.sleep(0.01)
                DONE = 1

async def run():
            g = gen()

v = await g.asend(None)
            self.assertEqual(v, 1)

v = await g.athrow(FooEr)
            self.assertEqual(v, 2000)

with self.assertRaises(StopAsyncIteration):
                await g.asend(None)

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 1)

def test_async_gen_asyncio_athrow_02(self):
        DONE = 0

class FooEr(Exception):
            pass

async def gen():
            nonlocal DONE
            try:
                await asyncio.sleep(0.01)
                try:
                    v = yield 1
                except FooEr:
                    await sleep_n_crash(0.01)
                yield v * 2
                await asyncio.sleep(0.01)
                # return
            finally:
                await asyncio.sleep(0.01)
                await asyncio.sleep(0.01)
                DONE = 1

async def run():
            g = gen()

v = await g.asend(None)
            self.assertEqual(v, 1)

try:
                await g.athrow(FooEr)
            except asyncio.CancelledError:
                self.assertEqual(DONE, 1)
                raise
            else:
                self.fail('CancelledError was not raised')

with self.assertRaises(asyncio.CancelledError):
            self.loop.run_until_complete(run())
        self.assertEqual(DONE, 1)

def test_async_gen_asyncio_athrow_03(self):
        DONE = 0

# test synchronous generators
        def foo():
            try:
                yield
            except:
                pass
        g = foo()
        g.send(None)
        with self.assertRaises(StopIteration):
            g.throw(ValueError)

# now with asynchronous generators

async def gen():
            nonlocal DONE
            try:
                yield
            except:
                pass
            DONE = 1

async def run():
            nonlocal DONE
            g = gen()
            await g.asend(None)
            with self.assertRaises(StopAsyncIteration):
                await g.athrow(ValueError)
            DONE += 10

self.loop.run_until_complete(run())
        self.assertEqual(DONE, 11)

def test_async_gen_asyncio_athrow_tuple(self):
        async def gen():
            try:
                yield 1
            except ZeroDivisionError:
                yield (2,)

async def run():
            g = gen()
            v = await g.asend(None)
            self.assertEqual(v, 1)
            v = await g.athrow(ZeroDivisionError)
            self.assertEqual(v, (2,))
            with self.assertRaises(StopAsyncIteration):
                await g.asend(None)

self.loop.run_until_complete(run())

def test_async_gen_asyncio_athrow_stopiteration(self):
        async def gen():
            try:
                yield 1
            except ZeroDivisionError:
                yield StopIteration(2)

async def run():
            g = gen()
            v = await g.asend(None)
            self.assertEqual(v, 1)
            v = await g.athrow(ZeroDivisionError)
            self.assertIsInstance(v, StopIteration)
            self.assertEqual(v.value, 2)
            with self.assertRaises(StopAsyncIteration):
                await g.asend(None)

self.loop.run_until_complete(run())

def test_async_gen_asyncio_shutdown_01(self):
        finalized = 0

async def waiter(timeout):
            nonlocal finalized
            try:
                await asyncio.sleep(timeout)
                yield 1
            finally:
                await asyncio.sleep(0)
                finalized += 1

async def wait():
            async for _ in waiter(1):
                pass

t1 = self.loop.create_task(wait())
        t2 = self.loop.create_task(wait())

self.loop.run_until_complete(asyncio.sleep(0.1))

# Silence warnings
        t1.cancel()
        t2.cancel()

with self.assertRaises(asyncio.CancelledError):
            self.loop.run_until_complete(t1)
        with self.assertRaises(asyncio.CancelledError):
            self.loop.run_until_complete(t2)

self.loop.run_until_complete(self.loop.shutdown_asyncgens())

self.assertEqual(finalized, 2)

def test_async_gen_asyncio_shutdown_02(self):
        messages = []

def exception_handler(loop, context):
            messages.append(context)

async def async_iterate():
            yield 1
            yield 2

it = async_iterate()
        async def main():
            loop = asyncio.get_running_loop()
            loop.set_exception_handler(exception_handler)

async for i in it:
                break

asyncio.run(main())

self.assertEqual(messages, [])

def test_async_gen_asyncio_shutdown_exception_01(self):
        messages = []

def exception_handler(loop, context):
            messages.append(context)

async def async_iterate():
            try:
                yield 1
                yield 2
            finally:
                1/0

it = async_iterate()
        async def main():
            loop = asyncio.get_running_loop()
            loop.set_exception_handler(exception_handler)

async for i in it:
                break

asyncio.run(main())

message, = messages
        self.assertEqual(message['asyncgen'], it)
        self.assertIsInstance(message['exception'], ZeroDivisionError)
        self.assertIn('an error occurred during closing of asynchronous generator',
                      message['message'])

def test_async_gen_asyncio_shutdown_exception_02(self):
        messages = []

def exception_handler(loop, context):
            messages.append(context)

async def async_iterate():
            try:
                yield 1
                yield 2
            finally:
                1/0

async def main():
            loop = asyncio.get_running_loop()
            loop.set_exception_handler(exception_handler)

async for i in async_iterate():
                break
            gc_collect()

asyncio.run(main())

message, = messages
        self.assertIsInstance(message['exception'], ZeroDivisionError)
        self.assertIn('unhandled exception during asyncio.run() shutdown',
                      message['message'])
        del message, messages
        gc_collect()

def test_async_gen_expression_01(self):
        async def arange(n):
            for i in range(n):
                await asyncio.sleep(0.01)
                yield i

def make_arange(n):
            # This syntax is legal starting with Python 3.7
            return (i * 2 async for i in arange(n))

async def run():
            return [i async for i in make_arange(10)]

res = self.loop.run_until_complete(run())
        self.assertEqual(res, [i * 2 for i in range(10)])

def test_async_gen_expression_02(self):
        async def wrap(n):
            await asyncio.sleep(0.01)
            return n

def make_arange(n):
            # This syntax is legal starting with Python 3.7
            return (i * 2 for i in range(n) if await wrap(i))

async def run():
            return [i async for i in make_arange(10)]

res = self.loop.run_until_complete(run())
        self.assertEqual(res, [i * 2 for i in range(1, 10)])

def test_asyncgen_nonstarted_hooks_are_cancellable(self):
        # See https://bugs.python.org/issue38013
        messages = []

def exception_handler(loop, context):
            messages.append(context)

async def async_iterate():
            yield 1
            yield 2

async def main():
            loop = asyncio.get_running_loop()
            loop.set_exception_handler(exception_handler)

async for i in async_iterate():
                break

asyncio.run(main())

self.assertEqual([], messages)
        gc_collect()

def test_async_gen_await_same_anext_coro_twice(self):
        async def async_iterate():
            yield 1
            yield 2

async def run():
            it = async_iterate()
            nxt = it.__anext__()
            await nxt
            with self.assertRaisesRegex(
                    RuntimeError,
                    r"cannot reuse already awaited __anext__\(\)/asend\(\)"
            ):
                await nxt

await it.aclose()  # prevent unfinished iterator warning

self.loop.run_until_complete(run())

def test_async_gen_await_same_aclose_coro_twice(self):
        async def async_iterate():
            yield 1
            yield 2

async def run():
            it = async_iterate()
            nxt = it.aclose()
            await nxt
            with self.assertRaisesRegex(
                    RuntimeError,
                    r"cannot reuse already awaited aclose\(\)/athrow\(\)"
            ):
                await nxt

self.loop.run_until_complete(run())

def test_async_gen_throw_same_aclose_coro_twice(self):
        async def async_iterate():
            yield 1
            yield 2

it = async_iterate()
        nxt = it.aclose()
        with self.assertRaises(StopIteration):
            nxt.throw(GeneratorExit)

with self.assertRaisesRegex(
            RuntimeError,
            r"cannot reuse already awaited aclose\(\)/athrow\(\)"
        ):
            nxt.throw(GeneratorExit)

def test_async_gen_throw_custom_same_aclose_coro_twice(self):
        async def async_iterate():
            yield 1
            yield 2

it = async_iterate()

class MyException(Exception):
            pass

nxt = it.aclose()
        with self.assertRaises(MyException):
            nxt.throw(MyException)

with self.assertRaisesRegex(
            RuntimeError,
            r"cannot reuse already awaited aclose\(\)/athrow\(\)"
        ):
            nxt.throw(MyException)

def test_async_gen_throw_custom_same_athrow_coro_twice(self):
        async def async_iterate():
            yield 1
            yield 2

it = async_iterate()

class MyException(Exception):
            pass

nxt = it.athrow(MyException)
        with self.assertRaises(MyException):
            nxt.throw(MyException)

with self.assertRaisesRegex(
            RuntimeError,
            r"cannot reuse already awaited aclose\(\)/athrow\(\)"
        ):
            nxt.throw(MyException)

def test_async_gen_aclose_twice_with_different_coros(self):
        # Regression test for https://bugs.python.org/issue39606
        async def async_iterate():
            yield 1
            yield 2

async def run():
            it = async_iterate()
            await it.aclose()
            await it.aclose()

self.loop.run_until_complete(run())

def test_async_gen_aclose_after_exhaustion(self):
        # Regression test for https://bugs.python.org/issue39606
        async def async_iterate():
            yield 1
            yield 2

async def run():
            it = async_iterate()
            async for _ in it:
                pass
            await it.aclose()

self.loop.run_until_complete(run())

def test_async_gen_aclose_compatible_with_get_stack(self):
        async def async_generator():
            yield object()

async def run():
            ag = async_generator()
            asyncio.create_task(ag.aclose())
            tasks = asyncio.all_tasks()
            for task in tasks:
                # No AttributeError raised
                task.get_stack()

self.loop.run_until_complete(run())

if __name__ == "__main__":
    unittest.main()

NAME	TYPE	LAST MODIFIED	SIZE	OWNER / GROUP	PERMISSIONS	ACTION
..
Sine-1000Hz-300ms.aif	f!le	2025-06-03 15:41	60.25 KB	root / linksafe	-rw-r--r--
__init__.py	f!le	2025-06-23 14:36	47 B	root / linksafe	-rw-r--r--
__main__.py	f!le	2025-06-23 14:36	67 B	root / linksafe	-rw-r--r--
_test_atexit.py	f!le	2025-06-23 14:36	3.61 KB	root / linksafe	-rw-r--r--
_test_eintr.py	f!le	2025-06-23 14:36	17.72 KB	root / linksafe	-rw-r--r--
_test_embed_set_config.py	f!le	2025-06-23 14:36	8.64 KB	root / linksafe	-rw-r--r--
_test_embed_structseq.py	f!le	2025-06-23 14:36	1.99 KB	root / linksafe	-rw-r--r--
_test_multiprocessing.py	f!le	2025-06-23 14:36	216.26 KB	root / linksafe	-rw-r--r--
_test_venv_multiprocessin...-.	f!le	2025-06-23 14:36	796 B	root / linksafe	-rw-r--r--
archiver_tests.py	f!le	2025-06-23 14:36	6.1 KB	root / linksafe	-rw-r--r--
audiotest.au	f!le	2025-06-03 15:41	27.48 KB	root / linksafe	-rw-r--r--
audiotests.py	f!le	2025-06-23 14:36	12.13 KB	root / linksafe	-rw-r--r--
audit-tests.py	f!le	2025-06-23 14:36	13.76 KB	root / linksafe	-rw-r--r--
autotest.py	f!le	2025-06-23 14:36	214 B	root / linksafe	-rw-r--r--
bisect_cmd.py	f!le	2025-06-23 14:36	5.36 KB	root / linksafe	-rwxr-xr-x
clinic.test.c	f!le	2025-06-03 15:41	139.1 KB	root / linksafe	-rw-r--r--
cmath_testcases.txt	f!le	2025-06-03 15:41	141.2 KB	root / linksafe	-rw-r--r--
curses_tests.py	f!le	2025-06-23 14:36	1.23 KB	root / linksafe	-rwxr-xr-x
datetimetester.py	f!le	2025-06-23 14:36	265.73 KB	root / linksafe	-rw-r--r--
dis_module.py	f!le	2025-06-23 14:36	76 B	root / linksafe	-rw-r--r--
empty.vbs	f!le	2025-06-03 15:41	70 B	root / linksafe	-rw-r--r--
exception_hierarchy.txt	f!le	2025-06-03 15:41	2.33 KB	root / linksafe	-rw-r--r--
floating_points.txt	f!le	2025-06-03 15:41	15.92 KB	root / linksafe	-rw-r--r--
fork_wait.py	f!le	2025-06-23 14:36	2.29 KB	root / linksafe	-rw-r--r--
formatfloat_testcases.txt	f!le	2025-06-03 15:41	7.45 KB	root / linksafe	-rw-r--r--
ieee754.txt	f!le	2025-06-03 15:41	3.15 KB	root / linksafe	-rw-r--r--
levenshtein_examples.json	f!le	2025-06-03 15:41	406.44 KB	root / linksafe	-rw-r--r--
list_tests.py	f!le	2025-06-23 14:36	16.9 KB	root / linksafe	-rw-r--r--
lock_tests.py	f!le	2025-06-23 14:36	35.64 KB	root / linksafe	-rw-r--r--
mailcap.txt	f!le	2025-06-03 15:41	1.24 KB	root / linksafe	-rw-r--r--
mapping_tests.py	f!le	2025-06-23 14:36	21.87 KB	root / linksafe	-rw-r--r--
math_testcases.txt	f!le	2025-06-03 15:41	23.19 KB	root / linksafe	-rw-r--r--
memory_watchdog.py	f!le	2025-06-23 14:36	711 B	root / linksafe	-rw-r--r--
mime.types	f!le	2025-06-03 15:41	47.37 KB	root / linksafe	-rw-r--r--
mock_socket.py	f!le	2025-06-23 14:36	3.69 KB	root / linksafe	-rw-r--r--
mp_fork_bomb.py	f!le	2025-06-23 14:36	448 B	root / linksafe	-rw-r--r--
mp_preload.py	f!le	2025-06-23 14:36	351 B	root / linksafe	-rw-r--r--
multibytecodec_support.py	f!le	2025-06-23 14:36	14.19 KB	root / linksafe	-rw-r--r--
pickletester.py	f!le	2025-06-23 14:36	172.37 KB	root / linksafe	-rw-r--r--
profilee.py	f!le	2025-06-23 14:36	2.97 KB	root / linksafe	-rw-r--r--
pstats.pck	f!le	2025-06-03 15:41	65.05 KB	root / linksafe	-rw-r--r--
pyclbr_input.py	f!le	2025-06-23 14:36	1.63 KB	root / linksafe	-rw-r--r--
pythoninfo.py	f!le	2025-06-23 14:36	28.35 KB	root / linksafe	-rw-r--r--
randv2_32.pck	f!le	2025-06-03 15:41	7.34 KB	root / linksafe	-rw-r--r--
randv2_64.pck	f!le	2025-06-03 15:41	7.19 KB	root / linksafe	-rw-r--r--
randv3.pck	f!le	2025-06-03 15:41	7.82 KB	root / linksafe	-rw-r--r--
re_tests.py	f!le	2025-06-23 14:36	25.94 KB	root / linksafe	-rwxr-xr-x
recursion.tar	f!le	2025-06-03 15:41	516 B	root / linksafe	-rw-r--r--
regrtest.py	f!le	2025-06-23 14:36	1.28 KB	root / linksafe	-rwxr-xr-x
relimport.py	f!le	2025-06-23 14:36	27 B	root / linksafe	-rw-r--r--
reperf.py	f!le	2025-06-23 14:36	538 B	root / linksafe	-rw-r--r--
seq_tests.py	f!le	2025-06-23 14:36	14.96 KB	root / linksafe	-rw-r--r--
signalinterproctester.py	f!le	2025-06-23 14:36	3.12 KB	root / linksafe	-rw-r--r--
ssl_servers.py	f!le	2025-06-23 14:36	7.12 KB	root / linksafe	-rw-r--r--
ssltests.py	f!le	2025-06-23 14:36	1.03 KB	root / linksafe	-rw-r--r--
string_tests.py	f!le	2025-06-23 14:36	71.24 KB	root / linksafe	-rw-r--r--
test___all__.py	f!le	2025-06-23 14:36	5.04 KB	root / linksafe	-rw-r--r--
test__locale.py	f!le	2025-06-23 14:36	12.52 KB	root / linksafe	-rw-r--r--
test__opcode.py	f!le	2025-06-23 14:36	4.14 KB	root / linksafe	-rw-r--r--
test__osx_support.py	f!le	2025-06-23 14:36	13.53 KB	root / linksafe	-rw-r--r--
test__xxinterpchannels.py	f!le	2025-06-23 14:36	52.19 KB	root / linksafe	-rw-r--r--
test__xxsubinterpreters.p...-.	f!le	2025-06-23 14:36	27.5 KB	root / linksafe	-rw-r--r--
test_abc.py	f!le	2025-06-23 14:36	23.81 KB	root / linksafe	-rw-r--r--
test_abstract_numbers.py	f!le	2025-06-23 14:36	5.81 KB	root / linksafe	-rw-r--r--
test_aifc.py	f!le	2025-06-23 14:36	17.84 KB	root / linksafe	-rw-r--r--
test_argparse.py	f!le	2025-06-23 14:36	218.49 KB	root / linksafe	-rw-r--r--
test_array.py	f!le	2025-06-23 14:36	55.44 KB	root / linksafe	-rw-r--r--
test_asdl_parser.py	f!le	2025-06-23 14:36	4.44 KB	root / linksafe	-rw-r--r--
test_asyncgen.py	f!le	2025-06-23 14:36	53.94 KB	root / linksafe	-rw-r--r--
test_atexit.py	f!le	2025-06-23 14:36	3.2 KB	root / linksafe	-rw-r--r--
test_audioop.py	f!le	2025-06-23 14:36	28.32 KB	root / linksafe	-rw-r--r--
test_audit.py	f!le	2025-06-23 14:36	9.22 KB	root / linksafe	-rw-r--r--
test_augassign.py	f!le	2025-06-23 14:36	7.68 KB	root / linksafe	-rw-r--r--
test_base64.py	f!le	2025-06-23 14:36	35.05 KB	root / linksafe	-rw-r--r--
test_baseexception.py	f!le	2025-06-23 14:36	7.77 KB	root / linksafe	-rw-r--r--
test_bdb.py	f!le	2025-06-23 14:36	44.17 KB	root / linksafe	-rw-r--r--
test_bigaddrspace.py	f!le	2025-06-23 14:36	2.83 KB	root / linksafe	-rw-r--r--
test_bigmem.py	f!le	2025-06-23 14:36	45.01 KB	root / linksafe	-rw-r--r--
test_binascii.py	f!le	2025-06-23 14:36	20.09 KB	root / linksafe	-rw-r--r--
test_binop.py	f!le	2025-06-23 14:36	14.14 KB	root / linksafe	-rw-r--r--
test_bisect.py	f!le	2025-06-23 14:36	16.63 KB	root / linksafe	-rw-r--r--
test_bool.py	f!le	2025-06-23 14:36	14.25 KB	root / linksafe	-rw-r--r--
test_buffer.py	f!le	2025-06-23 14:36	171.88 KB	root / linksafe	-rw-r--r--
test_bufio.py	f!le	2025-06-23 14:36	2.56 KB	root / linksafe	-rw-r--r--
test_builtin.py	f!le	2025-06-23 14:36	96.66 KB	root / linksafe	-rw-r--r--
test_bytes.py	f!le	2025-06-23 14:36	82.01 KB	root / linksafe	-rw-r--r--
test_bz2.py	f!le	2025-06-23 14:36	42.59 KB	root / linksafe	-rw-r--r--
test_c_locale_coercion.py	f!le	2025-06-23 14:36	20.99 KB	root / linksafe	-rw-r--r--
test_calendar.py	f!le	2025-06-23 14:36	51.78 KB	root / linksafe	-rw-r--r--
test_call.py	f!le	2025-06-23 14:36	35.21 KB	root / linksafe	-rw-r--r--
test_cgi.py	f!le	2025-06-23 14:36	22.27 KB	root / linksafe	-rw-r--r--
test_cgitb.py	f!le	2025-06-23 14:36	2.62 KB	root / linksafe	-rw-r--r--
test_charmapcodec.py	f!le	2025-06-23 14:36	1.77 KB	root / linksafe	-rw-r--r--
test_class.py	f!le	2025-06-23 14:36	22.02 KB	root / linksafe	-rw-r--r--
test_clinic.py	f!le	2025-06-23 14:36	85.41 KB	root / linksafe	-rw-r--r--
test_cmath.py	f!le	2025-06-23 14:36	22.47 KB	root / linksafe	-rw-r--r--
test_cmd.py	f!le	2025-06-23 14:36	6.49 KB	root / linksafe	-rw-r--r--
test_cmd_line.py	f!le	2025-06-23 14:36	39.51 KB	root / linksafe	-rw-r--r--
test_cmd_line_script.py	f!le	2025-06-23 14:36	34.93 KB	root / linksafe	-rw-r--r--
test_code.py	f!le	2025-06-23 14:36	25.7 KB	root / linksafe	-rw-r--r--
test_code_module.py	f!le	2025-06-23 14:36	12.73 KB	root / linksafe	-rw-r--r--
test_codeccallbacks.py	f!le	2025-06-23 14:36	49.23 KB	root / linksafe	-rw-r--r--
test_codecencodings_cn.py	f!le	2025-06-23 14:36	3.86 KB	root / linksafe	-rw-r--r--
test_codecencodings_hk.py	f!le	2025-06-23 14:36	701 B	root / linksafe	-rw-r--r--
test_codecencodings_iso20...-.	f!le	2025-06-23 14:36	3.65 KB	root / linksafe	-rw-r--r--
test_codecencodings_jp.py	f!le	2025-06-23 14:36	4.79 KB	root / linksafe	-rw-r--r--
test_codecencodings_kr.py	f!le	2025-06-23 14:36	2.96 KB	root / linksafe	-rw-r--r--
test_codecencodings_tw.py	f!le	2025-06-23 14:36	681 B	root / linksafe	-rw-r--r--
test_codecmaps_cn.py	f!le	2025-06-23 14:36	746 B	root / linksafe	-rw-r--r--
test_codecmaps_hk.py	f!le	2025-06-23 14:36	386 B	root / linksafe	-rw-r--r--
test_codecmaps_jp.py	f!le	2025-06-23 14:36	1.7 KB	root / linksafe	-rw-r--r--
test_codecmaps_kr.py	f!le	2025-06-23 14:36	1.16 KB	root / linksafe	-rw-r--r--
test_codecmaps_tw.py	f!le	2025-06-23 14:36	705 B	root / linksafe	-rw-r--r--
test_codecs.py	f!le	2025-06-23 14:36	137.42 KB	root / linksafe	-rw-r--r--
test_codeop.py	f!le	2025-06-23 14:36	8.68 KB	root / linksafe	-rw-r--r--
test_collections.py	f!le	2025-06-23 14:36	93.47 KB	root / linksafe	-rw-r--r--
test_colorsys.py	f!le	2025-06-23 14:36	4.27 KB	root / linksafe	-rw-r--r--
test_compare.py	f!le	2025-06-23 14:36	17.46 KB	root / linksafe	-rw-r--r--
test_compile.py	f!le	2025-06-23 14:36	81.24 KB	root / linksafe	-rw-r--r--
test_compileall.py	f!le	2025-06-23 14:36	48.53 KB	root / linksafe	-rw-r--r--
test_compiler_assemble.py	f!le	2025-06-23 14:36	2.46 KB	root / linksafe	-rw-r--r--
test_compiler_codegen.py	f!le	2025-06-23 14:36	1.72 KB	root / linksafe	-rw-r--r--
test_complex.py	f!le	2025-06-23 14:36	35.21 KB	root / linksafe	-rw-r--r--
test_configparser.py	f!le	2025-06-23 14:36	85.34 KB	root / linksafe	-rw-r--r--
test_contains.py	f!le	2025-06-23 14:36	3.35 KB	root / linksafe	-rw-r--r--
test_context.py	f!le	2025-06-23 14:36	31.1 KB	root / linksafe	-rw-r--r--
test_contextlib.py	f!le	2025-06-23 14:36	43.08 KB	root / linksafe	-rw-r--r--
test_contextlib_async.py	f!le	2025-06-23 14:36	23.99 KB	root / linksafe	-rw-r--r--
test_copy.py	f!le	2025-06-23 14:36	26.52 KB	root / linksafe	-rw-r--r--
test_copyreg.py	f!le	2025-06-23 14:36	4.36 KB	root / linksafe	-rw-r--r--
test_coroutines.py	f!le	2025-06-23 14:36	67.47 KB	root / linksafe	-rw-r--r--
test_cprofile.py	f!le	2025-06-23 14:36	9.44 KB	root / linksafe	-rw-r--r--
test_crashers.py	f!le	2025-06-23 14:36	1.17 KB	root / linksafe	-rw-r--r--
test_crypt.py	f!le	2025-06-23 14:36	4.19 KB	root / linksafe	-rw-r--r--
test_csv.py	f!le	2025-06-23 14:36	61.59 KB	root / linksafe	-rw-r--r--
test_curses.py	f!le	2025-06-23 14:36	50.14 KB	root / linksafe	-rw-r--r--
test_datetime.py	f!le	2025-06-23 14:36	2.67 KB	root / linksafe	-rw-r--r--
test_dbm.py	f!le	2025-06-23 14:36	6.83 KB	root / linksafe	-rw-r--r--
test_dbm_dumb.py	f!le	2025-06-23 14:36	11.08 KB	root / linksafe	-rw-r--r--
test_dbm_gnu.py	f!le	2025-06-23 14:36	7.64 KB	root / linksafe	-rw-r--r--
test_dbm_ndbm.py	f!le	2025-06-23 14:36	5.91 KB	root / linksafe	-rw-r--r--
test_decimal.py	f!le	2025-06-23 14:36	217.94 KB	root / linksafe	-rw-r--r--
test_decorators.py	f!le	2025-06-23 14:36	14.63 KB	root / linksafe	-rw-r--r--
test_defaultdict.py	f!le	2025-06-23 14:36	6.1 KB	root / linksafe	-rw-r--r--
test_deque.py	f!le	2025-06-23 14:36	33.16 KB	root / linksafe	-rw-r--r--
test_descr.py	f!le	2025-06-23 14:36	196.2 KB	root / linksafe	-rw-r--r--
test_descrtut.py	f!le	2025-06-23 14:36	10.98 KB	root / linksafe	-rw-r--r--
test_devpoll.py	f!le	2025-06-23 14:36	4.44 KB	root / linksafe	-rw-r--r--
test_dict.py	f!le	2025-06-23 14:36	51.33 KB	root / linksafe	-rw-r--r--
test_dict_version.py	f!le	2025-06-23 14:36	6.1 KB	root / linksafe	-rw-r--r--
test_dictcomps.py	f!le	2025-06-23 14:36	6.55 KB	root / linksafe	-rw-r--r--
test_dictviews.py	f!le	2025-06-23 14:36	14.82 KB	root / linksafe	-rw-r--r--
test_difflib.py	f!le	2025-06-23 14:36	21.47 KB	root / linksafe	-rw-r--r--
test_difflib_expect.html	f!le	2025-06-03 15:41	100.9 KB	root / linksafe	-rw-r--r--
test_dis.py	f!le	2025-06-23 14:36	83.45 KB	root / linksafe	-rw-r--r--
test_docxmlrpc.py	f!le	2025-06-23 14:36	9.1 KB	root / linksafe	-rw-r--r--
test_dtrace.py	f!le	2025-06-23 14:36	7.98 KB	root / linksafe	-rw-r--r--
test_dynamic.py	f!le	2025-06-23 14:36	6 KB	root / linksafe	-rw-r--r--
test_dynamicclassattribut...-.	f!le	2025-06-23 14:36	9.57 KB	root / linksafe	-rw-r--r--
test_eintr.py	f!le	2025-06-23 14:36	627 B	root / linksafe	-rw-r--r--
test_embed.py	f!le	2025-06-23 14:36	69.88 KB	root / linksafe	-rw-r--r--
test_ensurepip.py	f!le	2025-06-23 14:36	11.49 KB	root / linksafe	-rw-r--r--
test_enum.py	f!le	2025-06-23 14:36	188.15 KB	root / linksafe	-rw-r--r--
test_enumerate.py	f!le	2025-06-23 14:36	9.14 KB	root / linksafe	-rw-r--r--
test_eof.py	f!le	2025-06-23 14:36	7.94 KB	root / linksafe	-rw-r--r--
test_epoll.py	f!le	2025-06-23 14:36	9.4 KB	root / linksafe	-rw-r--r--
test_errno.py	f!le	2025-06-23 14:36	1.04 KB	root / linksafe	-rw-r--r--
test_except_star.py	f!le	2025-06-23 14:36	39.7 KB	root / linksafe	-rw-r--r--
test_exception_group.py	f!le	2025-06-23 14:36	34.03 KB	root / linksafe	-rw-r--r--
test_exception_hierarchy....-.	f!le	2025-06-23 14:36	7.54 KB	root / linksafe	-rw-r--r--
test_exception_variations...-.	f!le	2025-06-23 14:36	13.74 KB	root / linksafe	-rw-r--r--
test_exceptions.py	f!le	2025-06-23 14:36	83.63 KB	root / linksafe	-rw-r--r--
test_extcall.py	f!le	2025-06-23 14:36	14.69 KB	root / linksafe	-rw-r--r--
test_faulthandler.py	f!le	2025-06-23 14:36	30.31 KB	root / linksafe	-rw-r--r--
test_fcntl.py	f!le	2025-06-23 14:36	7.76 KB	root / linksafe	-rw-r--r--
test_file.py	f!le	2025-06-23 14:36	11.78 KB	root / linksafe	-rw-r--r--
test_file_eintr.py	f!le	2025-06-23 14:36	10.74 KB	root / linksafe	-rw-r--r--
test_filecmp.py	f!le	2025-06-23 14:36	11.98 KB	root / linksafe	-rw-r--r--
test_fileinput.py	f!le	2025-06-23 14:36	37.86 KB	root / linksafe	-rw-r--r--
test_fileio.py	f!le	2025-06-23 14:36	19.98 KB	root / linksafe	-rw-r--r--
test_fileutils.py	f!le	2025-06-23 14:36	951 B	root / linksafe	-rw-r--r--
test_finalization.py	f!le	2025-06-23 14:36	14.66 KB	root / linksafe	-rw-r--r--
test_float.py	f!le	2025-06-23 14:36	64.65 KB	root / linksafe	-rw-r--r--
test_flufl.py	f!le	2025-06-23 14:36	2.81 KB	root / linksafe	-rw-r--r--
test_fnmatch.py	f!le	2025-06-23 14:36	10.68 KB	root / linksafe	-rw-r--r--
test_fork1.py	f!le	2025-06-23 14:36	3.3 KB	root / linksafe	-rw-r--r--
test_format.py	f!le	2025-06-23 14:36	28.44 KB	root / linksafe	-rw-r--r--
test_fractions.py	f!le	2025-06-23 14:36	65.65 KB	root / linksafe	-rw-r--r--
test_frame.py	f!le	2025-06-23 14:36	14.04 KB	root / linksafe	-rw-r--r--
test_frozen.py	f!le	2025-06-23 14:36	2.2 KB	root / linksafe	-rw-r--r--
test_fstring.py	f!le	2025-06-23 14:36	64.74 KB	root / linksafe	-rw-r--r--
test_ftplib.py	f!le	2025-06-23 14:36	41.97 KB	root / linksafe	-rw-r--r--
test_funcattrs.py	f!le	2025-06-23 14:36	15.71 KB	root / linksafe	-rw-r--r--
test_functools.py	f!le	2025-06-23 14:36	114.02 KB	root / linksafe	-rw-r--r--
test_gc.py	f!le	2025-06-23 14:36	47.71 KB	root / linksafe	-rw-r--r--
test_generator_stop.py	f!le	2025-06-23 14:36	943 B	root / linksafe	-rw-r--r--
test_generators.py	f!le	2025-06-23 14:36	66.48 KB	root / linksafe	-rw-r--r--
test_genericalias.py	f!le	2025-06-23 14:36	17.78 KB	root / linksafe	-rw-r--r--
test_genericclass.py	f!le	2025-06-23 14:36	9.44 KB	root / linksafe	-rw-r--r--
test_genericpath.py	f!le	2025-06-23 14:36	22.7 KB	root / linksafe	-rw-r--r--
test_genexps.py	f!le	2025-06-23 14:36	7.3 KB	root / linksafe	-rw-r--r--
test_getopt.py	f!le	2025-06-23 14:36	6.94 KB	root / linksafe	-rw-r--r--
test_getpass.py	f!le	2025-06-23 14:36	6.37 KB	root / linksafe	-rw-r--r--
test_getpath.py	f!le	2025-06-23 14:36	44.36 KB	root / linksafe	-rw-r--r--
test_gettext.py	f!le	2025-06-23 14:36	41.96 KB	root / linksafe	-rw-r--r--
test_glob.py	f!le	2025-06-23 14:36	18.21 KB	root / linksafe	-rw-r--r--
test_global.py	f!le	2025-06-23 14:36	1.2 KB	root / linksafe	-rw-r--r--
test_grammar.py	f!le	2025-06-23 14:36	66.31 KB	root / linksafe	-rw-r--r--
test_graphlib.py	f!le	2025-06-23 14:36	8.31 KB	root / linksafe	-rw-r--r--
test_grp.py	f!le	2025-06-23 14:36	3.67 KB	root / linksafe	-rw-r--r--
test_gzip.py	f!le	2025-06-23 14:36	41.48 KB	root / linksafe	-rw-r--r--
test_hash.py	f!le	2025-06-23 14:36	12.11 KB	root / linksafe	-rw-r--r--
test_hashlib.py	f!le	2025-06-23 14:36	46.71 KB	root / linksafe	-rw-r--r--
test_heapq.py	f!le	2025-06-23 14:36	16.42 KB	root / linksafe	-rw-r--r--
test_hmac.py	f!le	2025-06-23 14:36	26.06 KB	root / linksafe	-rw-r--r--
test_html.py	f!le	2025-06-23 14:36	4.23 KB	root / linksafe	-rw-r--r--
test_htmlparser.py	f!le	2025-06-23 14:36	33.37 KB	root / linksafe	-rw-r--r--
test_http_cookiejar.py	f!le	2025-06-23 14:36	81.55 KB	root / linksafe	-rw-r--r--
test_http_cookies.py	f!le	2025-06-23 14:36	21.84 KB	root / linksafe	-rw-r--r--
test_httplib.py	f!le	2025-06-23 14:36	96.89 KB	root / linksafe	-rw-r--r--
test_httpservers.py	f!le	2025-06-23 14:36	56.64 KB	root / linksafe	-rw-r--r--
test_idle.py	f!le	2025-06-23 14:36	831 B	root / linksafe	-rw-r--r--
test_imaplib.py	f!le	2025-06-23 14:36	42.11 KB	root / linksafe	-rw-r--r--
test_imghdr.py	f!le	2025-06-23 14:36	4.81 KB	root / linksafe	-rw-r--r--
test_index.py	f!le	2025-06-23 14:36	8.37 KB	root / linksafe	-rw-r--r--
test_int.py	f!le	2025-06-23 14:36	33.97 KB	root / linksafe	-rw-r--r--
test_int_literal.py	f!le	2025-06-23 14:36	6.89 KB	root / linksafe	-rw-r--r--
test_interpreters.py	f!le	2025-06-23 14:36	32.11 KB	root / linksafe	-rw-r--r--
test_io.py	f!le	2025-06-23 14:36	183.89 KB	root / linksafe	-rw-r--r--
test_ioctl.py	f!le	2025-06-23 14:36	3.24 KB	root / linksafe	-rw-r--r--
test_ipaddress.py	f!le	2025-06-23 14:36	126.69 KB	root / linksafe	-rw-r--r--
test_isinstance.py	f!le	2025-06-23 14:36	12.95 KB	root / linksafe	-rw-r--r--
test_iter.py	f!le	2025-06-23 14:36	38.23 KB	root / linksafe	-rw-r--r--
test_iterlen.py	f!le	2025-06-23 14:36	7.1 KB	root / linksafe	-rw-r--r--
test_itertools.py	f!le	2025-06-23 14:36	113.53 KB	root / linksafe	-rw-r--r--
test_keyword.py	f!le	2025-06-23 14:36	2 KB	root / linksafe	-rw-r--r--
test_keywordonlyarg.py	f!le	2025-06-23 14:36	6.89 KB	root / linksafe	-rw-r--r--
test_kqueue.py	f!le	2025-06-23 14:36	9.36 KB	root / linksafe	-rw-r--r--
test_largefile.py	f!le	2025-06-23 14:36	11.05 KB	root / linksafe	-rw-r--r--
test_launcher.py	f!le	2025-06-23 14:36	28.75 KB	root / linksafe	-rw-r--r--
test_linecache.py	f!le	2025-06-23 14:36	12.56 KB	root / linksafe	-rw-r--r--
test_list.py	f!le	2025-06-23 14:36	9.6 KB	root / linksafe	-rw-r--r--
test_listcomps.py	f!le	2025-06-23 14:36	24.02 KB	root / linksafe	-rw-r--r--
test_lltrace.py	f!le	2025-06-23 14:36	3.71 KB	root / linksafe	-rw-r--r--
test_locale.py	f!le	2025-06-23 14:36	24.69 KB	root / linksafe	-rw-r--r--
test_logging.py	f!le	2025-06-23 14:36	251.7 KB	root / linksafe	-rw-r--r--
test_long.py	f!le	2025-06-23 14:36	63.4 KB	root / linksafe	-rw-r--r--
test_longexp.py	f!le	2025-06-23 14:36	233 B	root / linksafe	-rw-r--r--
test_lzma.py	f!le	2025-06-23 14:37	93 KB	root / linksafe	-rw-r--r--
test_mailbox.py	f!le	2025-06-23 14:36	93.91 KB	root / linksafe	-rw-r--r--
test_mailcap.py	f!le	2025-06-23 14:36	11.48 KB	root / linksafe	-rw-r--r--
test_marshal.py	f!le	2025-06-23 14:36	23.15 KB	root / linksafe	-rw-r--r--
test_math.py	f!le	2025-06-23 14:36	108.3 KB	root / linksafe	-rw-r--r--
test_math_property.py	f!le	2025-06-23 14:36	1.15 KB	root / linksafe	-rw-r--r--
test_memoryio.py	f!le	2025-06-23 14:36	32.65 KB	root / linksafe	-rw-r--r--
test_memoryview.py	f!le	2025-06-23 14:36	22.23 KB	root / linksafe	-rw-r--r--
test_metaclass.py	f!le	2025-06-23 14:36	6.19 KB	root / linksafe	-rw-r--r--
test_mimetypes.py	f!le	2025-06-23 14:36	15.74 KB	root / linksafe	-rw-r--r--
test_minidom.py	f!le	2025-06-23 14:36	68.42 KB	root / linksafe	-rw-r--r--
test_mmap.py	f!le	2025-06-23 14:36	38.56 KB	root / linksafe	-rw-r--r--
test_modulefinder.py	f!le	2025-06-23 14:36	12.21 KB	root / linksafe	-rw-r--r--
test_monitoring.py	f!le	2025-06-23 14:36	55.76 KB	root / linksafe	-rw-r--r--
test_msilib.py	f!le	2025-06-23 14:36	5.52 KB	root / linksafe	-rw-r--r--
test_multibytecodec.py	f!le	2025-06-23 14:36	15.79 KB	root / linksafe	-rw-r--r--
test_multiprocessing_main...-.	f!le	2025-06-23 14:36	11.48 KB	root / linksafe	-rw-r--r--
test_named_expressions.py	f!le	2025-06-23 14:36	29.62 KB	root / linksafe	-rw-r--r--
test_netrc.py	f!le	2025-06-23 14:36	11.86 KB	root / linksafe	-rw-r--r--
test_nis.py	f!le	2025-06-23 14:36	1.25 KB	root / linksafe	-rw-r--r--
test_nntplib.py	f!le	2025-06-23 14:36	62.7 KB	root / linksafe	-rw-r--r--
test_ntpath.py	f!le	2025-06-23 14:36	63.59 KB	root / linksafe	-rw-r--r--
test_numeric_tower.py	f!le	2025-06-23 14:36	8 KB	root / linksafe	-rw-r--r--
test_opcache.py	f!le	2025-06-23 14:36	10.89 KB	root / linksafe	-rw-r--r--
test_opcodes.py	f!le	2025-06-23 14:36	3.62 KB	root / linksafe	-rw-r--r--
test_openpty.py	f!le	2025-06-23 14:36	600 B	root / linksafe	-rw-r--r--
test_operator.py	f!le	2025-06-23 14:36	26.72 KB	root / linksafe	-rw-r--r--
test_optparse.py	f!le	2025-06-23 14:36	61.39 KB	root / linksafe	-rw-r--r--
test_ordered_dict.py	f!le	2025-06-23 14:36	39.96 KB	root / linksafe	-rw-r--r--
test_os.py	f!le	2025-06-23 14:36	181.05 KB	root / linksafe	-rw-r--r--
test_ossaudiodev.py	f!le	2025-06-23 14:36	7.27 KB	root / linksafe	-rw-r--r--
test_osx_env.py	f!le	2025-06-23 14:36	1.31 KB	root / linksafe	-rw-r--r--
test_pathlib.py	f!le	2025-06-23 14:36	138.01 KB	root / linksafe	-rw-r--r--
test_patma.py	f!le	2025-06-23 14:36	86.6 KB	root / linksafe	-rw-r--r--
test_pdb.py	f!le	2025-06-23 14:36	92.92 KB	root / linksafe	-rw-r--r--
test_peepholer.py	f!le	2025-06-23 14:36	40.6 KB	root / linksafe	-rw-r--r--
test_pep646_syntax.py	f!le	2025-06-23 14:36	7.79 KB	root / linksafe	-rw-r--r--
test_perf_profiler.py	f!le	2025-06-23 14:36	11.44 KB	root / linksafe	-rw-r--r--
test_perfmaps.py	f!le	2025-06-23 14:36	685 B	root / linksafe	-rw-r--r--
test_pickle.py	f!le	2025-06-23 14:36	21.24 KB	root / linksafe	-rw-r--r--
test_picklebuffer.py	f!le	2025-06-23 14:36	4.99 KB	root / linksafe	-rw-r--r--
test_pickletools.py	f!le	2025-06-23 14:36	16.78 KB	root / linksafe	-rw-r--r--
test_pipes.py	f!le	2025-06-23 14:36	6.79 KB	root / linksafe	-rw-r--r--
test_pkg.py	f!le	2025-06-23 14:36	9.59 KB	root / linksafe	-rw-r--r--
test_pkgutil.py	f!le	2025-06-23 14:36	26.22 KB	root / linksafe	-rw-r--r--
test_platform.py	f!le	2025-06-23 14:36	21.53 KB	root / linksafe	-rw-r--r--
test_plistlib.py	f!le	2025-06-23 14:36	41.25 KB	root / linksafe	-rw-r--r--
test_poll.py	f!le	2025-06-23 14:36	7.39 KB	root / linksafe	-rw-r--r--
test_popen.py	f!le	2025-06-23 14:36	2.36 KB	root / linksafe	-rw-r--r--
test_poplib.py	f!le	2025-06-23 14:36	18.02 KB	root / linksafe	-rw-r--r--
test_positional_only_arg....-.	f!le	2025-06-23 14:36	18.44 KB	root / linksafe	-rw-r--r--
test_posix.py	f!le	2025-06-23 14:36	96.25 KB	root / linksafe	-rw-r--r--
test_posixpath.py	f!le	2025-06-23 14:36	44.92 KB	root / linksafe	-rw-r--r--
test_pow.py	f!le	2025-06-23 14:36	6.38 KB	root / linksafe	-rw-r--r--
test_pprint.py	f!le	2025-06-23 14:36	50.59 KB	root / linksafe	-rw-r--r--
test_print.py	f!le	2025-06-23 14:36	8.05 KB	root / linksafe	-rw-r--r--
test_profile.py	f!le	2025-06-23 14:36	8.69 KB	root / linksafe	-rw-r--r--
test_property.py	f!le	2025-06-23 14:36	19.33 KB	root / linksafe	-rw-r--r--
test_pstats.py	f!le	2025-06-23 14:36	4.31 KB	root / linksafe	-rw-r--r--
test_pty.py	f!le	2025-06-23 14:36	16.18 KB	root / linksafe	-rw-r--r--
test_pulldom.py	f!le	2025-06-23 14:36	12.33 KB	root / linksafe	-rw-r--r--
test_pwd.py	f!le	2025-06-23 14:36	4.32 KB	root / linksafe	-rw-r--r--
test_py_compile.py	f!le	2025-06-23 14:36	11.93 KB	root / linksafe	-rw-r--r--
test_pyclbr.py	f!le	2025-06-23 14:36	10.25 KB	root / linksafe	-rw-r--r--
test_pyexpat.py	f!le	2025-06-23 14:36	29.35 KB	root / linksafe	-rw-r--r--
test_queue.py	f!le	2025-06-23 14:36	20.61 KB	root / linksafe	-rw-r--r--
test_quopri.py	f!le	2025-06-23 14:36	7.87 KB	root / linksafe	-rw-r--r--
test_raise.py	f!le	2025-06-23 14:36	13.44 KB	root / linksafe	-rw-r--r--
test_random.py	f!le	2025-06-23 14:36	57.01 KB	root / linksafe	-rw-r--r--
test_range.py	f!le	2025-06-23 14:36	26.53 KB	root / linksafe	-rw-r--r--
test_re.py	f!le	2025-06-23 14:36	144.79 KB	root / linksafe	-rw-r--r--
test_readline.py	f!le	2025-06-23 14:36	15.72 KB	root / linksafe	-rw-r--r--
test_regrtest.py	f!le	2025-06-23 14:36	92.51 KB	root / linksafe	-rw-r--r--
test_repl.py	f!le	2025-06-23 14:36	6.34 KB	root / linksafe	-rw-r--r--
test_reprlib.py	f!le	2025-06-23 14:36	29.07 KB	root / linksafe	-rw-r--r--
test_resource.py	f!le	2025-06-23 14:36	7.12 KB	root / linksafe	-rw-r--r--
test_richcmp.py	f!le	2025-06-23 14:36	11.95 KB	root / linksafe	-rw-r--r--
test_rlcompleter.py	f!le	2025-06-23 14:36	7.4 KB	root / linksafe	-rw-r--r--
test_robotparser.py	f!le	2025-06-23 14:36	11.02 KB	root / linksafe	-rw-r--r--
test_runpy.py	f!le	2025-06-23 14:36	33.99 KB	root / linksafe	-rw-r--r--
test_sax.py	f!le	2025-06-23 14:36	54.63 KB	root / linksafe	-rw-r--r--
test_sched.py	f!le	2025-06-23 14:36	7.38 KB	root / linksafe	-rw-r--r--
test_scope.py	f!le	2025-06-23 14:36	21.94 KB	root / linksafe	-rw-r--r--
test_script_helper.py	f!le	2025-06-23 14:36	5.82 KB	root / linksafe	-rw-r--r--
test_secrets.py	f!le	2025-06-23 14:36	4.28 KB	root / linksafe	-rw-r--r--
test_select.py	f!le	2025-06-23 14:36	3.42 KB	root / linksafe	-rw-r--r--
test_selectors.py	f!le	2025-06-23 14:36	19.64 KB	root / linksafe	-rw-r--r--
test_set.py	f!le	2025-06-23 14:36	71.31 KB	root / linksafe	-rw-r--r--
test_setcomps.py	f!le	2025-06-23 14:36	5.24 KB	root / linksafe	-rw-r--r--
test_shelve.py	f!le	2025-06-23 14:36	6.42 KB	root / linksafe	-rw-r--r--
test_shlex.py	f!le	2025-06-23 14:36	13.39 KB	root / linksafe	-rw-r--r--
test_shutil.py	f!le	2025-06-23 14:36	136.86 KB	root / linksafe	-rw-r--r--
test_signal.py	f!le	2025-06-23 14:36	52.58 KB	root / linksafe	-rw-r--r--
test_site.py	f!le	2025-06-23 14:36	29.77 KB	root / linksafe	-rw-r--r--
test_slice.py	f!le	2025-06-23 14:36	9.46 KB	root / linksafe	-rw-r--r--
test_smtplib.py	f!le	2025-06-23 14:36	60.02 KB	root / linksafe	-rw-r--r--
test_smtpnet.py	f!le	2025-06-23 14:36	3.03 KB	root / linksafe	-rw-r--r--
test_sndhdr.py	f!le	2025-06-23 14:36	1.51 KB	root / linksafe	-rw-r--r--
test_socket.py	f!le	2025-06-23 14:36	260.03 KB	root / linksafe	-rw-r--r--
test_socketserver.py	f!le	2025-06-23 14:36	17.39 KB	root / linksafe	-rw-r--r--
test_sort.py	f!le	2025-06-23 14:36	13.59 KB	root / linksafe	-rw-r--r--
test_source_encoding.py	f!le	2025-06-23 14:36	12.65 KB	root / linksafe	-rw-r--r--
test_spwd.py	f!le	2025-06-23 14:36	2.83 KB	root / linksafe	-rw-r--r--
test_ssl.py	f!le	2025-06-23 14:36	216.52 KB	root / linksafe	-rw-r--r--
test_stable_abi_ctypes.py	f!le	2025-06-23 14:36	24.75 KB	root / linksafe	-rw-r--r--
test_startfile.py	f!le	2025-06-23 14:36	1.7 KB	root / linksafe	-rw-r--r--
test_stat.py	f!le	2025-06-23 14:36	8.92 KB	root / linksafe	-rw-r--r--
test_statistics.py	f!le	2025-06-23 14:36	120.02 KB	root / linksafe	-rw-r--r--
test_strftime.py	f!le	2025-06-23 14:36	7.4 KB	root / linksafe	-rw-r--r--
test_string.py	f!le	2025-06-23 14:36	21.86 KB	root / linksafe	-rw-r--r--
test_string_literals.py	f!le	2025-06-23 14:36	14.1 KB	root / linksafe	-rw-r--r--
test_stringprep.py	f!le	2025-06-23 14:36	3.04 KB	root / linksafe	-rw-r--r--
test_strptime.py	f!le	2025-06-23 14:36	41.95 KB	root / linksafe	-rw-r--r--
test_strtod.py	f!le	2025-06-23 14:36	20.06 KB	root / linksafe	-rw-r--r--
test_struct.py	f!le	2025-06-23 14:36	39.18 KB	root / linksafe	-rw-r--r--
test_structseq.py	f!le	2025-06-23 14:36	7.72 KB	root / linksafe	-rw-r--r--
test_subclassinit.py	f!le	2025-06-23 14:36	8.04 KB	root / linksafe	-rw-r--r--
test_subprocess.py	f!le	2025-06-23 14:36	161.37 KB	root / linksafe	-rw-r--r--
test_sunau.py	f!le	2025-06-23 14:36	6.09 KB	root / linksafe	-rw-r--r--
test_sundry.py	f!le	2025-06-23 14:36	1.02 KB	root / linksafe	-rw-r--r--
test_super.py	f!le	2025-06-23 14:36	14.79 KB	root / linksafe	-rw-r--r--
test_support.py	f!le	2025-06-23 14:36	27.05 KB	root / linksafe	-rw-r--r--
test_symtable.py	f!le	2025-06-23 14:36	17.56 KB	root / linksafe	-rw-r--r--
test_syntax.py	f!le	2025-06-23 14:36	73.78 KB	root / linksafe	-rw-r--r--
test_sys.py	f!le	2025-06-23 14:36	67.37 KB	root / linksafe	-rw-r--r--
test_sys_setprofile.py	f!le	2025-06-23 14:36	14.53 KB	root / linksafe	-rw-r--r--
test_sys_settrace.py	f!le	2025-06-23 14:36	84.56 KB	root / linksafe	-rw-r--r--
test_sysconfig.py	f!le	2025-06-23 14:36	26.08 KB	root / linksafe	-rw-r--r--
test_syslog.py	f!le	2025-06-23 14:36	4.7 KB	root / linksafe	-rw-r--r--
test_tabnanny.py	f!le	2025-06-23 14:36	13.9 KB	root / linksafe	-rw-r--r--
test_tarfile.py	f!le	2025-06-23 14:36	175.15 KB	root / linksafe	-rw-r--r--
test_tcl.py	f!le	2025-06-23 14:36	30.3 KB	root / linksafe	-rw-r--r--
test_telnetlib.py	f!le	2025-06-23 14:36	12.85 KB	root / linksafe	-rw-r--r--
test_tempfile.py	f!le	2025-06-23 14:36	75.5 KB	root / linksafe	-rw-r--r--
test_termios.py	f!le	2025-06-23 14:36	10.96 KB	root / linksafe	-rw-r--r--
test_textwrap.py	f!le	2025-06-23 14:36	41.89 KB	root / linksafe	-rw-r--r--
test_thread.py	f!le	2025-06-23 14:36	8.87 KB	root / linksafe	-rw-r--r--
test_threadedtempfile.py	f!le	2025-06-23 14:36	1.93 KB	root / linksafe	-rw-r--r--
test_threading.py	f!le	2025-06-23 14:36	74.21 KB	root / linksafe	-rw-r--r--
test_threading_local.py	f!le	2025-06-23 14:36	7.01 KB	root / linksafe	-rw-r--r--
test_threadsignals.py	f!le	2025-06-23 14:36	9.87 KB	root / linksafe	-rw-r--r--
test_time.py	f!le	2025-06-23 14:36	44.65 KB	root / linksafe	-rw-r--r--
test_timeit.py	f!le	2025-06-23 14:36	15.2 KB	root / linksafe	-rw-r--r--
test_timeout.py	f!le	2025-06-23 14:36	10.74 KB	root / linksafe	-rw-r--r--
test_tix.py	f!le	2025-06-23 14:36	1.05 KB	root / linksafe	-rw-r--r--
test_tokenize.py	f!le	2025-06-23 14:36	118 KB	root / linksafe	-rw-r--r--
test_trace.py	f!le	2025-06-23 14:36	21.52 KB	root / linksafe	-rw-r--r--
test_traceback.py	f!le	2025-06-23 14:36	144.4 KB	root / linksafe	-rw-r--r--
test_tracemalloc.py	f!le	2025-06-23 14:36	40.97 KB	root / linksafe	-rw-r--r--
test_ttk_textonly.py	f!le	2025-06-23 14:36	16.69 KB	root / linksafe	-rw-r--r--
test_tty.py	f!le	2025-06-23 14:36	3.63 KB	root / linksafe	-rw-r--r--
test_tuple.py	f!le	2025-06-23 14:36	19.8 KB	root / linksafe	-rw-r--r--
test_turtle.py	f!le	2025-06-23 14:36	14.04 KB	root / linksafe	-rw-r--r--
test_type_aliases.py	f!le	2025-06-23 14:36	12.74 KB	root / linksafe	-rw-r--r--
test_type_annotations.py	f!le	2025-06-23 14:36	6.23 KB	root / linksafe	-rw-r--r--
test_type_cache.py	f!le	2025-06-23 14:36	6.6 KB	root / linksafe	-rw-r--r--
test_type_comments.py	f!le	2025-06-23 14:36	10.5 KB	root / linksafe	-rw-r--r--
test_type_params.py	f!le	2025-06-23 14:36	38.87 KB	root / linksafe	-rw-r--r--
test_typechecks.py	f!le	2025-06-23 14:36	2.55 KB	root / linksafe	-rw-r--r--
test_types.py	f!le	2025-06-23 14:36	82.38 KB	root / linksafe	-rw-r--r--
test_typing.py	f!le	2025-06-23 14:36	343.33 KB	root / linksafe	-rw-r--r--
test_ucn.py	f!le	2025-06-23 14:36	9.71 KB	root / linksafe	-rw-r--r--
test_unary.py	f!le	2025-06-23 14:36	1.52 KB	root / linksafe	-rw-r--r--
test_unicode.py	f!le	2025-06-23 14:36	125.43 KB	root / linksafe	-rw-r--r--
test_unicode_file.py	f!le	2025-06-23 14:36	5.72 KB	root / linksafe	-rw-r--r--
test_unicode_file_functio...-.	f!le	2025-06-23 14:36	6.91 KB	root / linksafe	-rw-r--r--
test_unicode_identifiers....-.	f!le	2025-06-23 14:36	997 B	root / linksafe	-rw-r--r--
test_unicodedata.py	f!le	2025-06-23 14:36	17.01 KB	root / linksafe	-rw-r--r--
test_univnewlines.py	f!le	2025-06-23 14:36	3.85 KB	root / linksafe	-rw-r--r--
test_unpack.py	f!le	2025-06-23 14:36	3.51 KB	root / linksafe	-rw-r--r--
test_unpack_ex.py	f!le	2025-06-23 14:36	9.98 KB	root / linksafe	-rw-r--r--
test_unparse.py	f!le	2025-06-23 14:36	27.96 KB	root / linksafe	-rw-r--r--
test_urllib.py	f!le	2025-06-23 14:36	72.62 KB	root / linksafe	-rw-r--r--
test_urllib2.py	f!le	2025-06-23 14:36	80.82 KB	root / linksafe	-rw-r--r--
test_urllib2_localnet.py	f!le	2025-06-23 14:36	25.64 KB	root / linksafe	-rw-r--r--
test_urllib2net.py	f!le	2025-06-23 14:36	13.96 KB	root / linksafe	-rw-r--r--
test_urllib_response.py	f!le	2025-06-23 14:36	2.04 KB	root / linksafe	-rw-r--r--
test_urllibnet.py	f!le	2025-06-23 14:36	9.41 KB	root / linksafe	-rw-r--r--
test_urlparse.py	f!le	2025-06-23 14:36	81.41 KB	root / linksafe	-rw-r--r--
test_userdict.py	f!le	2025-06-23 14:36	7.56 KB	root / linksafe	-rw-r--r--
test_userlist.py	f!le	2025-06-23 14:36	1.97 KB	root / linksafe	-rw-r--r--
test_userstring.py	f!le	2025-06-23 14:36	2.52 KB	root / linksafe	-rw-r--r--
test_utf8_mode.py	f!le	2025-06-23 14:36	10.31 KB	root / linksafe	-rw-r--r--
test_utf8source.py	f!le	2025-06-23 14:36	1.08 KB	root / linksafe	-rw-r--r--
test_uu.py	f!le	2025-06-23 14:36	9.2 KB	root / linksafe	-rw-r--r--
test_uuid.py	f!le	2025-06-23 14:36	44.28 KB	root / linksafe	-rw-r--r--
test_venv.py	f!le	2025-06-23 14:36	37.42 KB	root / linksafe	-rw-r--r--
test_wait3.py	f!le	2025-06-23 14:36	1.74 KB	root / linksafe	-rw-r--r--
test_wait4.py	f!le	2025-06-23 14:36	1.14 KB	root / linksafe	-rw-r--r--
test_wave.py	f!le	2025-06-23 14:36	7.64 KB	root / linksafe	-rw-r--r--
test_weakref.py	f!le	2025-06-23 14:36	74.32 KB	root / linksafe	-rw-r--r--
test_weakset.py	f!le	2025-06-23 14:36	16.3 KB	root / linksafe	-rw-r--r--
test_webbrowser.py	f!le	2025-06-23 14:36	10.5 KB	root / linksafe	-rw-r--r--
test_winapi.py	f!le	2025-06-23 14:36	2.63 KB	root / linksafe	-rw-r--r--
test_winconsoleio.py	f!le	2025-06-23 14:36	7.6 KB	root / linksafe	-rw-r--r--
test_winreg.py	f!le	2025-06-23 14:36	22.48 KB	root / linksafe	-rw-r--r--
test_winsound.py	f!le	2025-06-23 14:36	5.17 KB	root / linksafe	-rw-r--r--
test_with.py	f!le	2025-06-23 14:36	27.78 KB	root / linksafe	-rw-r--r--
test_wmi.py	f!le	2025-06-23 14:36	3.31 KB	root / linksafe	-rw-r--r--
test_wsgiref.py	f!le	2025-06-23 14:36	29.32 KB	root / linksafe	-rw-r--r--
test_xdrlib.py	f!le	2025-06-23 14:36	2.25 KB	root / linksafe	-rw-r--r--
test_xml_dom_minicompat.p...-.	f!le	2025-06-23 14:36	4.18 KB	root / linksafe	-rw-r--r--
test_xml_dom_xmlbuilder.p...-.	f!le	2025-06-23 14:36	3.1 KB	root / linksafe	-rw-r--r--
test_xml_etree.py	f!le	2025-06-23 14:36	168.95 KB	root / linksafe	-rw-r--r--
test_xml_etree_c.py	f!le	2025-06-23 14:36	9.34 KB	root / linksafe	-rw-r--r--
test_xmlrpc.py	f!le	2025-06-23 14:36	58.08 KB	root / linksafe	-rw-r--r--
test_xmlrpc_net.py	f!le	2025-06-23 14:36	954 B	root / linksafe	-rw-r--r--
test_xxlimited.py	f!le	2025-06-23 14:36	2.46 KB	root / linksafe	-rw-r--r--
test_xxtestfuzz.py	f!le	2025-06-23 14:36	690 B	root / linksafe	-rw-r--r--
test_yield_from.py	f!le	2025-06-23 14:36	50.23 KB	root / linksafe	-rw-r--r--
test_zipapp.py	f!le	2025-06-23 14:36	16.7 KB	root / linksafe	-rw-r--r--
test_zipfile64.py	f!le	2025-06-23 14:36	5.78 KB	root / linksafe	-rw-r--r--
test_zipimport.py	f!le	2025-06-23 14:37	31.88 KB	root / linksafe	-rw-r--r--
test_zipimport_support.py	f!le	2025-06-23 14:36	10.57 KB	root / linksafe	-rw-r--r--
test_zlib.py	f!le	2025-06-23 14:36	41.66 KB	root / linksafe	-rw-r--r--
testcodec.py	f!le	2025-06-23 14:36	1.02 KB	root / linksafe	-rw-r--r--
testtar.tar	f!le	2025-06-03 15:41	425 KB	root / linksafe	-rw-r--r--
testtar.tar.xz	f!le	2025-06-03 15:41	172 B	root / linksafe	-rw-r--r--
tf_inherit_check.py	f!le	2025-06-23 14:36	714 B	root / linksafe	-rw-r--r--
time_hashlib.py	f!le	2025-06-23 14:36	2.87 KB	root / linksafe	-rw-r--r--
win_console_handler.py	f!le	2025-06-23 14:36	1.38 KB	root / linksafe	-rw-r--r--
xmltests.py	f!le	2025-06-23 14:36	499 B	root / linksafe	-rw-r--r--
zip_cp437_header.zip	f!le	2025-06-03 15:41	270 B	root / linksafe	-rw-r--r--
zipdir.zip	f!le	2025-06-03 15:41	374 B	root / linksafe	-rw-r--r--
zipdir_backslash.zip	f!le	2025-06-03 15:41	192 B	root / linksafe	-rw-r--r--

ÿØÿî