According to the [documentation](https://docs.python.org/3/library/io.html#io.IOBase), `io.IOBase` has no public constructors.  Yet I can create objects from it:

$ python3.5
Python 3.5.0 (default, Sep 13 2015, 17:20:05) 
[GCC 4.4.7 20120313 (Red Hat 4.4.7-16)] on linux
Type "help", "copyright", "credits" or "license" for more information.
Python are go!
>>> import io
>>> p = io.IOBase()
>>> p.readable()
False
>>> p.closed
False
# etc...

It doesn't do much, but the documentation is not consistent with the behaviour in practice.

“No public constructor” to me means that it is not defined how or if you can construct instances other than by the public subclasses. What do you expect to happen? How do you expect the public subclasses such as FileIO and BufferedReader to work if the base constructor does not work?

The other three base classes (RawIOBase, BufferedIOBase, TextIOBase) also say “there is no public constructor”. However allowing custom subclasses of these is very useful, so I would actually be for removing these restrictions from the documentation, and instead saying that each constructor accepts no arguments.

When the documentation says there is no public constructor, I expected it would be impossible to create instances, as in:

TypeError: cannot create 'builtin_function_or_method' instances

Perhaps I misunderstand the documentation.

Martin, I agree with changing the doc. Gerrit misunderstood because 'no public constructors' is either meaningless or wrong.  We do not usually talk about public versus private constructors.  This sounds more like C++ than Python.

For Python namespaces, names that start with '_' are private by convention unless documented otherwise.  Special names (__x__) are private in the sense that they are not usually used except by methods of the class; special methods are usually accessed by syntax or public names.  For class C, the default constructor is C.__new__, accessed by calling C.  (Let us not worry about other methods here.)  If C is a public name, with no '_', as is 'IOBase', then to me it has/is a public constructor.  Like other classes, IOBase has .__new__ and calling it produces an instance, as Gerrit discovered.  In that sense, it is not truly abstract.

I believe 'has no public constructor' is intended to mean 'has no documented signature and should not be *directly* called."  (If subclasses do call the base, then the signature should be documented.)

If existing subclasses like FileIO call the base, that is an implementation detail. But custom subclasses of the Raw, Buffered, and Text base classes should not be prohibited from chain calling the base’s __init__() method, nor should they have to override __init__() if there is no special initialization to be done. For IOBase itself, I don’t see a strong argument either way, but it makes sense to keep it consistent with the other three base classes.

I propose this patch, which changes “There is no public constructor” to “The constructor accepts no arguments”. In my mind this blesses making custom subclasses, which already seems to be tested and used in practice.

Martin's patch needs to be converted to a GitHub PR and reviewed.

"IOBase" is a public name and IOBase has an __init__ method.  It definitely has a public constructor.  However, like other abstract base classes, it is not meant to be directly instantiated by users other than writers of other classes.  Ditto for the 3 other io ABCs.  Because this is generic to all ABCs, it need not be repeated for each.

The proposed replacement is the opposite of the truth.  Rather than accepting no arguments, IOBase, like the ABCs in numbers and collections.abc, has a generic signature and accepts any arguments (which I believe are ignored).

>>> io.IOBase.__init__.__text_signature__
'($self, /, *args, **kwargs)'
>>> io.IOBase(3, a=5)
<io.IOBase object at 0x000001CF6A13D6C0>

A class, such as `object`, accepting no arguments other that self raises.  (At one time, object had the generic signature above.)

>>> object(3)
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    object(3)
TypeError: object() takes no arguments

I think that the fix should be to delete the original incorrect statement and not replace it with another incorrect statement.

Most abstract base classes are in collections.abc and numbers.  They are not specifically labelled 'abstract base class' in their docstrings because they are in modules consisting more or less entirely of ABCs.  Since io is mostly a module of concrete classes, I think it appropriate to specifically label them, as they are now.  Once so labeled, nothing need be added that is true of all ABCs.

> I think that the fix should be to delete the original incorrect statement and not replace it with another incorrect statement.


I agree with this.

New changeset cedd2473a9bebe07f3ced4f341cf58a2fef07b03 by slateny in branch 'main':
bpo-25415: Remove confusing sentence from IOBase docstrings (PR-31631)
https://github.com/python/cpython/commit/cedd2473a9bebe07f3ced4f341cf58a2fef07b03

New changeset 01df048831eb631dfee41175f08d09b9ad1a9538 by Miss Islington (bot) in branch '3.9':
bpo-25415: Remove confusing sentence from IOBase docstrings (PR-31631)
https://github.com/python/cpython/commit/01df048831eb631dfee41175f08d09b9ad1a9538

New changeset bdce1880365990403efdbeb60c4928c996370b0c by Miss Islington (bot) in branch '3.10':
bpo-25415: Remove confusing sentence from IOBase docstrings (PR-31631)
https://github.com/python/cpython/commit/bdce1880365990403efdbeb60c4928c996370b0c