Split the pool package objects in modules

Move task implementations to the pool object

Make psycopg3.pool a package

Use the daemon param at constructor rather than the attribute

Use the connections in the pool uniformly

I feel this is a better use than using some more than other (e.g. in
term of bloat of the connections associated with the resources) and
gives a more predictable performance of the connection (there won't be
some cold, some hot).

Now there aren't really "unused connections" to single out in order to
shrink the pool. So keep a tally of the number of connections unused and
use a worker thread to close some if there are above minconn unused in a
period.

Change state in critical section on pool.close()

Nothing bad should happen, because what maintains the state respect the
_closed state. However because the logic is complex make it more
defensive.

Make any pool task schedulable

Added interface to the pool to schedule a task in the future.

Don't lose pool connections giving them to a clients already timed out

Allow proxy tests to fail on Travis

Don't know why it fails, it requires interactive investigation there.
Make sure tests can run connecting on TCP socket and avoid SSH in the
proxy anyway. Not that any of this worked...

Wait worker thread to stop on pool close

Don't print warning gc'ing a pool in incomplete state

pool.close() called on del, idemptotent

Add separate setup_timeout param for pool

Allow 0 too, which would fill the pool in background.

Drop _sec suffix from pool timeouts

Python is consistent enough to use seconds everywhere timeouts are
involved.

Add pool reconnection retry

Don't try to rollback on exit if the connection is bad

Use a weak reference to avoid loops between pool and maintenance tasks

Add scheduler class

To be used in the connection pool to implement reconnection with
backoff, maybe periodic tasks.

Add test for pool kwargs

Default number of pool workers bumped to 3

Shrink the pool when connections have been idle long enough

Pool behaviour on start changed: block on __init__ until minconn
connections have been obtained or raise PoolTimeout if timeout_sec have
passed. Not doing so makes complicated to understand, when a connection
is requested, if it's done during initialisation, and avoid an unneeded
grow request.

Don't waste a worker thread adding a connection to the pool

Force pool num_workers to be > 0

it might work with num_workers = 0, however it's not trivial, there is
some deadlock to avoid at creation time.

Allow the pool to grow

Make the pool maintenance tasks base class abstract

Delete an eventual task-pool loop in StopWorker too

Add pool docstrings

Add connection pool close()

When the pool is closed, raise an exception in the thread of the clients
already waiting and refuse new requests. Let the current request finish
anyway.

Make sure the pool can be deleted with no warning

Make sure to delete reference loops between the pool and the maintenance
tasks after they have run.

Do not raise a warning if a connection in a pool is deleted without
being closed as this is a normal condition (imagining a pool being
created as a global object).

Add pool context test

Awake the pool client outside the critical section

Reset the connection status returning it to the pool

Add basic pool functionality test for queuing and timeout

Display the name in the connection pool repr

Add ConnectionPool class sketch

It has a pool of connections alright, workers, clients waiting list.

Only minconn implemented, no maintenance thread etc. It's a start.

@logilab is backing psycopg3!

Merci beaucoup!

Welcoming @dalibo as backer

Vive la France!

Fix concurrency test

It was blocking because the committer was a too busy loop never yielding
to the other worker.

Use gather instead of wait in tests to be coro friendly

Bump mypy version

ci: get token to rebuild docs from secrets

Merge branch 'ci-gh-actions'

Yaml lint

Run leak tests with both text and binary output

At the moment the output text is actually skipped but it will run once
text input is no more xfailed.

Fix binary argument of conn.cursor() in tests

Argument 'binary' of connection.cursor() should be a bool.
This follows up on 467d20bd0315a62b4c7377d8a0b170ece08ef99c (change from
'format' to 'binary').

ci: consistent uppercase in steps titles

ci: Test with Python 3.9 and PostgreSQL 13

Test different combination of Python and Postgres in the different
implementation to cover more cases.

ci: Allow lint and test on any branch

ci: colour tests output

tox: use the github action "python" value as toxenv name

ci; Use PG* env vars to define the connection string

ci: Fix test dsn

The github runner /etc/host file is pretty broken and localhost resolves
to ipv6, so use 127.0.0.1 to connect.

ci: sort out connection to postgresql service

ci: split tests in one job for each implementation

To simplify the matrix

ci: move tests to gh actions

ci: move docs building to gh actions

ci: move lint task to gh actions

Update script to trigger docs rebuild to use travis-ci.com

Retry server-side cursor tests on del

Warnings seem unreliably to receive. Also print any eventual unexpected
warning: pytest doesn't do it automatically.

Add fixture to help retrying flaky tests

Tried to use a couple of pytest plugins for retrying but they don't work
well with asyncio.

Make the DBAPI errors appear defined in the psycopg3 module

Drop psycopg3.pq.PQerror

Use an OperationalError instead (of which PQerror was a subclass), which
is better documented.

Add doc example about how to detect a disconnection

Add Connection.fileno()

Fix return error without exception on PQsocket call of broken connection

Still some weirdness here around: the method raises an exception on my
box (both with unix and tcp socket) but it seems to raise still a valid
number on certain databases on Travis. Make sure, in the test, at least
that it is a reasonable value.

Fix documentation of Cursor.pgresult

Merge branch 'row-factory'

Add tuple_row test

Make the nametuple_row() test independent from other tests

Add test for row_factory with cursor.stream()

Optimise the cython path around the use of row_maker

Make cursor.row_factory writable

Make the row_maker non-optional

Use the `tuple` type as return value for `tuple_row()`, which has a
valid interface and can also be used in the Cython code to fast-path the
case where the tuples created internally are good enough.

Fix use of TypeInfo with connections using dict_row

Actually always use dict_row as it makes things easier (we do create a
dict out of the query to pass kwargs...)

Relax the RowFactory signature to make it accept `dict_row()` and
`namedtuple_row()` too.

Add public package attributes

They are useful to allow people to annotate programs with psycopg3 types.

Fix type specification for `namedtuple_row()`

Fix row factory docs examples

Make the row_factory attribute non-nullable

Added a `tuple_row()` factory for completeness. Note that it returns None, not
a callable, and the row_maker on the Transformer hasn't changed. The
signature of RowFactory now allows that.

This
makes simpler to specify the row_factory option on `conn.cursor()`: None
means default (the connection `row_factory`), specifying `tuple_row()`
overrides it to the normal tuplish behaviour.

Drop row_factory param from Connection.execute()

The method is not present on cursor.execute: either it's on both or on
none. Erring on the side of a less complex interface for the moment...

Add namedtuple_row row factory

Implementation for namedtuple class cache and fields name sanitizing is
taken from psycogp2.

Document row factories

We document the row_factory argument of *Connection.execute() as well as
the row_factory attribute on Connection.

We add a new page in advanced section explaining the concepts of row
factories, providing examples and documenting built-in row factories.

Fix guard for platforms missing epoll

See #34

Don't use epoll module definitions if it's not the default selector

Close #34

Move docs example statement where it makes more sense

Start a 'psycopg3.rows' module with dict_row()

Merge pull request #33 from dlax/tox-docs

add a tox environment to build the docs

Add a tox environment to build the docs

Make lru_cache usage in libpq_docs compatible with python 3.7

The "user_function" version (allowing uncalled lru_cache) is only
available since python 3.8.

Add row_factory as connection attribute and connect argument

When passing 'row_factory' to connect(), respective attribute will be
set on the connection instance. This will be used as default at cursor
creation and can be overridden with conn.cursor(row_factory=...) or
conn.execute(row_factory=...).

We use a '_null_row_factory' marker to handle None-value passed to
.cursor() or .execute() for disabling the default row factory.

Fix server-side cursors docs typos

Reported by @lelit, thank you!

Let Transformer.make_row property's setter accept None

Add tests to verify broken queries or other statements in server-side cursors

Enforce passing a single statement by making sure to use the advanced
query protocol.

Set up row maker and loaders only once in a server-side cursor lifetime

It wasn't happening once per movement, as I was fearing, but it was happening
exactly twice: once on DECLARE, once on describe_portal(). We actually
don't care about the DECLARE result: it was being set on the cursor only
to detect errors, so now that's done manually.

Fix setting row maker on nextset()

The test was broken and didn't test that the row_factory function was
really called.

Merge branch 'master' into row-factory

Merge branch 'tx-no-auto-loaders'

Don't recalculate loaders when not needed

The case it's not needed is when the new result is guaranteed to have
the same fields as the previous one. This happens querying in single-row
mode and on server-side cursors fetch.

Dropped Transformer.pgresult setter, use set_result

Can pass a boolean to tell it to skip setting row loaders

Fix fetch*() return type annotation on server-side cursors

Add tests to verify row_factory works with server-side cursors too