Base TimeTz loader on regexp

Further tweaks to date/time loaders

Base time loader on regexp

Some 5x faster

Base date and timestamp loaders on regexp instead of strptime

Not only is 4x faster, but it's more straightforward to port to C
and keep similar algorithms (even if we decide to drop regexp in C)

Separate date/time tests in classes

Fix datetime timezone adjustment on Python 3.6

Add test for timestamptz timezone load behaviour

Add docs and tests for ConnectionInfo.timezone

Move timezone attribute to the Connection.info interface

Type changed to the abstract `datetime.tzinfo` so that we have the
option to return something else such as a `datetime.timezone` with fixed
offset.

Added function to retrieve the object internally from the PGconn.

Warn only once about unknown zoneinfo

Return timestamptz in the connection timezone

First cut, more tests to add. All current tests pass, except the
explicit checks for UTC tzinfo returned.

See https://github.com/psycopg/psycopg3/discussions/56

Merge branch 'master' into binary-datetime

Make the dependency on typing_extension optional

Return timestamptz as utc datetime loading in text format

This makes text and binary loaders return the same value. It also fixes
the problem of the missing seconds in the timezone offset on Python 3.6.

The opposite choice, returning datetime in the connection timezone on
binary loading, doesn't seem really feasible: pytz cannot parse all the
Postgres timezone values (for instance, "+02:00" can't be parsed): take
a look at
https://www.postgresql.org/docs/13/datetime-posix-timezone-specs.html to
understand how much of a bad idea it would be.

Fix timestamptz binary tests with seconds in the timezone on Python 3.6

Consider loss of precision in negative binary timestamps too

Add timedelta/interval binary adapter

Add timestamptz adapter

Force text query in tests playing with datestyle

Just in case in the future we switch to binary return values and we stop
testing anything.

Add datetime binary adapter

Only for naive datetimes, timezone not handled yet.

Add timetz binary adapters

Add time binary adapters

No timezone yet, some tests fail.

Add date binary adapters

Drop unused import

Merge branch 'binary-numeric'

Improve wording of docker testing notes

Add example about running tests in docker

Writing it down as I have to hack it together every time.

Fix dumping Decimal of the form 0E+n

Fix test for ConnectionInfo.hostaddr and libpq < 12

Add script to test the pool performance

Add benchmark test for binary numeric

Conclusion is that for the moment it is better to leave default Decimal
dump to text format. Better performance can be obtained accessing the
Python C Decimal structure and perform conversion from there.

Use faster C mod operator in Decimal dump

Add C implementation of Decimal dumper

Don't dump an excess of right 0's in Decimal to numeric

Add Cython implementation of NumericBinaryLoader

Add C implementation of text decimal adapters

Add dumper for Python int to numeric

Handle Decimal sNaN value

Dump numeric as binary without manipulating the digits tuple

Will make for a much faster algorithm in C

Decimal binary dump algorithm streamlined

Add Decimal values to random tests

Add prototype for a decimal binary dumper

The algorithm is pretty unwieldy, maybe it can be refactored. But tests
show that it should be correct.

Upgrade testing libraries (#50)

Use latest versions of testing libraries

pytest is broken on Python 3.10, until version 6.2.4.

Add numeric binary loader

Add pytest marker to skip tests on certain server versions

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'