import abc

from annotationlib import Format, get_annotations

import builtins

import collections

import collections.abc

import copy

from itertools import permutations

import pickle

from random import choice

import re

import sys

from test import support

import threading

import time

import typing

import unittest

import unittest.mock

import weakref

import gc

from weakref import proxy

import contextlib

from inspect import Signature

from test.support import ALWAYS_EQ

from test.support import import_helper

from test.support import threading_helper

from test.support import cpython_only

from test.support import EqualToForwardRef

import functools

py_functools = import_helper.import_fresh_module('functools',

blocked=['_functools'])

c_functools = import_helper.import_fresh_module('functools',

fresh=['_functools'])

decimal = import_helper.import_fresh_module('decimal', fresh=['_decimal'])

def replaced_module(name, replacement):

sys.modules[name] = original_module

def capture(*args, **kw):

"""capture all positional and keyword arguments"""

return args, kw

def signature(part):

""" return the signature of a partial object """

return (part.func, part.args, part.keywords, part.__dict__)

class MyTuple(tuple):

pass

class BadTuple(tuple):

def __add__(self, other):

return list(self) + list(other)

class MyDict(dict):

pass

class TestImportTime(unittest.TestCase):

)

class TestPartial:

self.assertEqual(result, expected)

class TestPartialC(TestPartial, unittest.TestCase):

partial_cm(map2, map2)

class TestPartialPy(TestPartial, unittest.TestCase):

module = py_functools

partial = py_functools.partial

if c_functools:

class CPartialSubclass(c_functools.partial):

pass

class PyPartialSubclass(py_functools.partial):

pass

class TestPartialCSubclass(TestPartialC):

test_nested_optimization = None

class TestPartialPySubclass(TestPartialPy):

self.assertEqual(p2(0), 0)

class TestPartialMethod(unittest.TestCase):

self.assertEqual(p2.__get__(0)(), 0)

class TestUpdateWrapper(unittest.TestCase):