I'd expect isinstance(tempfile.TemporaryFile(), io.IOBase) to be True as you can read() from and write() to the temp file.

However, on Python 3.6.5 64 bit on Windows 7 above isinstance() == False and and type(tempfile.TemporaryFile()) == tempfile._TemporaryFileWrapper, which has no super class (other than object).
Whereas, on Python 3.6.1 on iOS 11.4 (Pythonista 3.2) above isinstance() == True and type(tempfile.TemporaryFile()) == io.BufferedRandom, which has io.IOBase as its (indirect) super class.
The difference is likely caused by tempfile line 565 that equals TemporaryFile = NamedTemporaryFile in case of Windows.

This may be somewhat related to issue 26175, but isn't a duplicate as 26175 is on a temp file's attributes, and this issue is on its type

Martin, I added you because this Tempfile issue is related to #26175.

I think it is an implementation detail whether the result subclasses IOBase or just implements its API. Why do you want to check the base class, and why IOBase in particular, rather than BufferedIOBase, RawIOBase, or TextIOBase?

This is breaking aiohttp client file multipart uploads from temporary files. I'd be willing to bet that a lot of libraries do isinstance(foo, io.IOBase) deep in their guts.

Confirming this to be a thing on Python 3.7.5 / OS X 10.15.1.

In [31]: f = tempfile.NamedTemporaryFile()
In [32]: isinstance(f, io.IOBase)
Out[32]: False

Affected as well:
Python 3.8.0 (default, Nov  3 2019, 10:55:54)
[Clang 11.0.0 (clang-1100.0.33.8)] on darwin

Even if make TemporaryFile a subclass of IOBase (I am not sure we should do this) you could only use this in Python 3.9 and newer. I think it is better to fix this issue on the aiohttp side. aiohttp already registers payload types for a bunch of file-like types. You can also register it yourself:

aiohttp.payload.PAYLOAD_REGISTRY.register(aiohttp.payload.IOBasePayload, tempfile.TemporaryFile)

Seems IOBasePayload needs only read() and close() methods.

Agree, aiohttp can be fixed easily.

If somebody wants to make a pull request -- you are welcome!
https://github.com/aio-libs/aiohttp/issues/4432

Actually things are more complex. TemporaryFile is not a class, it is a function, so it does not make sense to use it with isinstance(). And if add support for TemporaryFile, NamedTemporaryFile and SpooledTemporaryFile should be supported too.

It may be easier to use a virtual subclassing: register IOBasePayload with a class which has an __instancecheck__() method which checks the existence of attributes "read" and "close".

TemporaryFile() returns an instance of _TemporaryFileWrapper.  isinstance(TemporaryFile(), io.IOBase) is a sensible thing to do and would be True if _TemporaryFileWrapper subclassed the appropriate io base file.

The base class for IDLE's stdxxx pseudofiles does this and hence, for instance,

>>> sys.stdout
<idlelib.run.StdOutputFile object at 0x0000023BEB515F70>
>>> isinstance(sys.stdout, io.IOBase)
True

I believe that tempfile long predates io, added in 2.6.  Since the IO base classes are not 'abstract base classes' in the sense of subclassing abc.ABCMeta, the tempfile classes cannot just be registered as implementing them.  And tempfile has never been re-written to be based on io, by subclassing io base classes.

Doing so would fix this issue.  It *might* result in simpler tempfile code (but I would not be sure until it is done).  It would also address (but not automatically fix) #26175. I think SpooledTemporaryFile would likely be the hardest.  Martin and Serhiy are correct that a change would be an enhancement, not a bugfix.

I have doubts that making _TemporaryFileWrapper a subclass of IOBase can make it simpler. It can make it more complex. _TemporaryFileWrapper is a proxy class with the __getattr__ method which not just return attributes of the underlying file, but wraps methods so they have references to the _TemporaryFileWrapper instance. If subclass IOBase you will need to write implementations of all methods of IOBase and its subclasses. You could also to reproduce the hierarhy of io classes to support binary and text, buffered and unbuffered files.

IDLE's pseudofiles are simpler because they represent only text files.

Looking at the tempfile code more, I agree with Serhiy that changing it should be rejected.  Python is a duck-typed language (essentially what Martin said). People should not be over-zealous in using instance checks.
 
The doc specifically says that TemporaryFile returns a *file-like object*
https://docs.python.org/3/glossary.html#term-file-like-object
which only require implementing the interface.