Fix typo in doc title

Check documentation build in CI

Add regression test for the infinity date example

Add an adaptation example for infinity date

Take from https://www.psycopg.org/articles/2020/11/24/psycopg3-adaptation/

Bypass call to _get_optimised if using the Python implementation

Dumpers ownership dict micro-optimisation

Copying is ~10x faster than creating a new dict.

Fixed adapters copy-on-write

If a wider context is customised don't affect smaller contexts already
created.

Use an explicit dumper map for the auto format.

The dumper chosen in auto format is the last one registered, if both the
text and binary ones are available. For all the builtin types the
preferred format is binary, except for strings and for json.

Dumping strings as text by default was handled by a special case; now
they are just handled by registering the text dumper after the binary
one. Json is now text by default, because it's marginally more
efficient.

Fix a typo in adaptation documentation

Merge branch 'type-row'

Further negotiation for good row types docs

Improvements can be made, however I would rather merge this branch to
master and improve the whole docs.

Proofread row factories doc

Improve row factory docs

Describe the protocol objects too. Expose them in the `psycopg3.rows`
module.

Add typing docs and example for psycopg3.rows

Drop RowConn from proto

Use a more local CursorRow definition.

Define an AnyCursor type alias

This will make it easier to define custom row factories without having
to use BaseCursor[Any, <rowtype>] as the connection type is not
meaningful in this context.

We expose this name instead of BaseCursor in top-level package
accordingly.

Bump up tests timeout on github action

Add typing test for cursor iteration

Fix typing of server-side cursors fetchmany/fetchall

Fix `Connection.connect()` return type

Now `connect()` returns a `Connection[Tuple]`, whereas
`connect(row_factory=something)` return the type of what row factory
produces. The implementation of this is somewhat brittle, but that's
mypy for you: @dlax (thank you!) noticed that defining `**kwargs:
Union[str, int]` helped to disambiguate the row_factory param. I guess
we will make a best-effort to maintain this "interface". Everything is
to be documented.

Strangely, mypy cannot figure out the type of

    conn = await self.connection_class.connect(
        self.conninfo, **self.kwargs
    )

in the async pool, but it can for the sync one (without the `await`).
Added explicit type to disambiguate, on both the classes, for symmetry.

Added regression tests to verify that refactoring doesn't break type
inference.

Illustrate type annotations in row factories documentation

Check test_typing with mypy as part of the pytest run

Make Connection generic on Row

We use a type variable 'RowConn' for Connection that is distinct from
'Row' that is used on Cursor side in order to reflect the possibility to
have distinct row factories on connection and cursor sides.

In order to avoid "propagation" of the Row type variable of Connection
classes, we use Any everywhere that variable is not used (namely,
everywhere outside the connection module).

The typing_example.py almost works: connect(row_factory=...) returns a
typed Connection, but only connect() still returns a Connection[Any].

Define Connection's row_factory as a property

This is similar to Cursor class and will make things easier in following
changes, making Connection generic on row type.

Avoid repeating the default row_factory in Connection methods

We set the default row_factory argument value to None in connect()
methods and use row_factory class attribute when unspecified, thus
avoiding repetition of the 'tuple_row' value.

Add a typing example (mypy) test

This example is checked by running mypy on it with both Python and C
implementation.

By having cursor and record values' type declared before assignment, we
make sure that expected types are consistent (otherwise mypy would raise
"Incompatible types in assignment" errors).

Example check_row_factory_connection() is still incomplete because
Connection is not generic on Row; it thus contain many Any types.

Change directory in tox's 'tests' environments

This avoids path manipulation and would help with the next commit (where
current directory will matter).

Make Cursor generic on Row

We make RowMaker, RowFactory and Cursor types generic on a Row type
variable thus making type inference work on cursor's fetch*() methods.

For example:

    R = TypeVar("R")
    def my_row_factory(cursor: BaseCursor[Any, R]) -> Callable[[Sequence[Any]], R]:
        ...

    with conn.cursor(row_factory=my_row_factory) as cur:
        cur.execute("select 1")
        reveal_type(cur)
        # Revealed type is 'psycopg3.cursor.Cursor[R`-1]'
        r = cur.fetchone()
        reveal_type(r)
        # Revealed type is 'Union[R`-1, None]'

The definition of RowMaker and RowFactory protocols needs two distinct
type variable because the former is covariant on Row (using 'Row_co'
type variable) and the latter is invariant on Row.

In Cursor.__init__(), row_factory argument is now required as we remove
its default value 'tuple_row'; this is helpful in order to keep Cursor
definition generic on Row, which would be more difficult when specifying
a concrete RowFactory by default binding Row to Tuple.

The Connection is not (yet) generic on Row, so we use RowFactory[Any].
Still, in cursor() methods, we get a fully typed Cursor value when a
row_factory argument is passed. We add two overloaded variants of these
cursor() methods depending on whether row_factory is passed or not (in
the former case, we return a Cursor[Row], in the latter case, a
Cursor[Any]).

A noticeable improvement is that we no longer need to explicitly declare
or ignore types in Transformer's load_row() and load_rows() as this is
not correctly inferred. Similarly, type annotations are not needed
anymore in callers of these methods (Cursor's fetch*() methods).
In TypeInfo's fetch*() method, we can drop superfluous type annotations.

Move 'make_row' attribute from Transformer to Cursor

Having this attribute defined in Transformer protocol will be
problematic when making the RowMaker protocol generic on Row because
we'll then have to also make Transformer generic on Row and
"propagating" the type variable will produce a lot of churn in the code
base.

Also, the variance (covariant) of Row in RowMaker will conflict with that
in Transformer (invariant).

On the other hand, keeping the RowMaker value and its underlying
RowFactory together/attached to the same object (now Cursor) seems
safer for consistency.

Remove constraints on Row TypeVar

It's not clear why there is both Tuple[Any, ...] and Any as possible
types for Row and since Any is one possibility it seems that anything is
possible so those constraints appear to be useless.

We can now remove a few '# type: ignore[no-any-return]' in
*Cursor.fetchone(). On the other hand, mypy wants us to declare the type
of 'records' values coming from transformer's load_rows():

    error: Need type annotation for 'records' (hint: "records: List[<type>] = ...")  [var-annotated]

Adjust return type of ServerCursorHelper._fetch_gen()

This method returns cur._tx.load_rows() which return type is List[Row].

We now need 'type: ignore[no-any-return]' in fetchone() methods or
server cursor classes, similarly as in client cursor classes.

Separate C and Python pgresult_ptr attribute names

The distinction is not used yet. However, let's do that for consistency
with pgconn_ptr.

Separate C and Python pgconn_ptr attribute names

Now that we are tapping into ctypes to access to the libpq dynamically
the Python value is handy for the cython layer too (see PGconn.hostaddr
implementation).

Merge branch 'conn-info'

Allow reading needs_password, used_password on broken connections

It makes sense (especially the former: it is used to detect if a
password was needed). However they are not that easy to use because a
failed connection attempt will throw an exception. For this reason they
are not added to ConnectionInfo.

Add ConnectionInfo.error_message, backend_pid

Further ConnectionInfo docs improvements

More compact doc rendering of introspected property types

Ensure pgconn_ptr, pgresult_ptr to return int in every implementation

Add ConnInfo.hostaddr

Also add C implementation of PGconn.hostaddr.

Add ConnectionInfo.server_version, protocol_version

Add ConnectionInfo docs

Add ConnectionInfo.parameter_status

Drop use of PQerror in ConnectionInfo

Test password not included in ConnectionInfo.get_parameters()

Added some flesh to the connection.info object

Only change logging level if not set

See #43

Use automatic type hints in docs

The result is not perfect but it can be improved. Better than redefining
all the types.

Fix missing dsn in async pool tests too

Pass 'dsn' value to ConnectionPool in tests

Otherwise, those tests fail when there's no database named after current
user (typically, 'connection failed: database "denis" does not exist').

Alias Task to asyncio.Future for python version < 3.8

This resolves the following mypy error on Python 3.7:

  psycopg3/psycopg3/pool/async_pool.py:72: error: Argument 1 to "append" of "list" has incompatible type "Future[None]"; expected "Task[None]" [arg-type]

Fix test run with no --loop selected

Test psycopg3 with uvloop

It works, it seems.

Add tests readme

Merge branch 'quiet-logger'

Use public logger names (to be documented)

Use "psycopg3" and "psycopg3.pool" as loggers which can be addressed.

Also cleanup of random inconsistencies around logging.

Set the psycopg3 logger at warning level

Close #43. See that ticket for relevant discussion.

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()