Re-export names from psycopg3.types

This is useful to silent mypy errors when implicit reexport is disabled
(e.g. in strict mode) like:

    error: Module 'psycopg3.types' does not explicitly export attribute
    'Jsonb'; implicit reexport disabled  [attr-defined]

https://mypy.readthedocs.io/en/stable/command_line.html#cmdoption-mypy-no-implicit-reexport

Accordingly, we import Int4 from psycopg3.types directly in
test_copy.py.

Shorten tracebacks executing on connection too

Cut traceback on execute short

Users don't care where in psycopg the error comes.

Dump all string subclasses as text by default

Useful for enums.

Fix dump of enum subtypes

Drop outdated change behaviour from docs

Grazie tante per il vostro aiuto, @20tab!

Added sentry (@getsentry) as a backer

Thank you very much :)

Added bit.io (@bitdotioinc) as top sponsor

Amazing, thank you!

Typo

Fix typo in pool with usage

Merge branch 'connection-pool'

Better looking default params for pool in the docs

Rename pool minconn, maxconn params to min_size, max_size

Change pool stat requests_timeout to requests_errors, include queue full

pool 'queue_length' stats renamed to 'requests_waiting'

Add pool.max_waiting

Pool docs corrections

Divide docs file into chapter directories

Add connection pool docs

Grow the pool size one connection at time

Not doing so saturates the worker processes which may not be able to do
other maintenance, including returning connections to the pool. It also
helps to limit the amount of growth in a sudden spike.
o

Add logging to pool.wait()

Don't use a worker in pool.putconn() if not needed

If _reset is not set there is little work to do so the overhead of a
context switch is measurable and not necessary.

pool: fix off-by-one error in shrink log message

Add async pool stats

Add pool connection_class parameter

Make pool params keyword only in subclasses too

Add pool stats

Add reset callback to connection pool

Make sure that the pool config function leaves connections in idle state

Rename pool.wait_ready() to pool.wait()

Drop especially flaky async test dealing with del behaviour

Add AsyncConnectionPool.check()

Simpler, more approximative, more reliable pool max lifetime test

More tolerance in schedule timing tests

Add test for pool config

Don't throw an error on context exit if the connection is closed

Make the async pool unavailable on Python 3.6

Because of https://bugs.python.org/issue42600 or thereabout.

Don't use threads to manage the scheduler and workers of async tasks

Add an async scheduler

Drop get_running_loop call on async pool close

Add compat module for python versions compatibility

Add pool.check()

Set a timeout for the test run

retry flaky max lifetime test

Add Connection.broken

Add max_lifetime to pool connections

Add jitter method to pool

Use more of the pool context manager in the tests

Retry flaky tests a few times

Add pool context managers

Add pool.resize()

Make cleanup tests more reliable

Unfortunately there is some race condition on delete and for now just
using a timer.

In order to limit the problem don't actually run the StopWorker task but
bail out from the workers as soon as seen.

Fix Python 3.6 compatibility issues in async pool

Add async connection pool

Move non-blocking pool functionalities to a generic base class

Note that running maintenance threads is "non-blocking" and will be
thread-based in the async pool.

Add pool.wait_ready, drop connection_timeout on init

This way init should never block. Always fill the connection in
background but a client can decide if they want to wait for it to be
ready.

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