Dropped params from Cursor.copy()

Never tested... and they don't work.

Added some documentation on the adaptation system

Added initial docs for psycopg3.pq module

Added installation instructions including the binary package

Use the build script to build source packages too

Create the psycopg3-binary package

Added in-progress script to build wheel packages

Pure Python implementation called 'python', not 'ctypes'

Use "pip install psycogp3[c]" to install the C extension

Merge branch 'c-dumpers'

Cursor.callproc dropped

The method has a simplistic semantic which doesn't account for
PostgreSQL positional parameters, procedures, set-returning functions.
Users can use a normal `Cursor.execute()` with SELECT
function_name(...)` or CALL procedure_name(...)` instead.

Api docs and typing system made consistent

Top-level objects are annotated as coming from the main package: this
way the documentation can link them consistently to where they are
documented (e.g. `Connection` is `psycopg3.Connection`, not
`psycopg3.connection.Connection`) and MyPy is happy too.

Cursor.connection made a read-only property

Dropped "-> None" from function returning no result in docs

Added errors module documentation

Added documentation for the `sql` module

Added C string dumpers

C Dumpers and Loaders attributes readable from Python

Use the right class instantiating a dumper on a subclass

Added oid constants in cython extension

Added C bool dumpers (text, binary)

Added C implementation of int dumpers (text, binary)

s/loaders/adapters/ where there will be dumpers too

Docs cleanup

Including hiding the constructors of classes which aren't supposed to be
initialised directly by the user.

COPY operations update cursor.rowcount

Copy.read() changed to return b"" on EOF, consistently with file.read().
Also changed copy generators to return the final result of the
operation, and pgconn.get_copy_data() to always return bytes as second
argument, because it will never return an empty string unless on error.

With this changeset all psycopg2 test_copy pass, both sync and async.

Added test to verify can't execute(copy)

Typo in async with example fixed

Document async with connection and cursor

Delay decisions about transaction operations to __enter__

The transaction status of the connection may change concurrently between
__init__ and __enter__.

Fixed async copy example

Added rollback case to the transaction block example

More docs about Rollback usage

Avoid a cython call in bool loaders

It's probably inlined, but there is still the exception handler around.

Fixed overflow argument for float loader

Added documentation for Rollback

Merge branch 'nested-transactions'

More efficient float loading

Use "private" savepoint name to avoid conflicting with user ones

"s1" is too common.

Also omit ``savepoint`` in sql statements: it is a noise word

Added documentation for transaction management

Map errors 08* to OperationalError

See https://github.com/psycopg/psycopg2/pull/1148

Transaction tests cleanup

Fixed transaction behaviour when there is a transaction already started

State management simplified too.

Commands to enter/exit a transaction with named savepoint tweaked

- Batch together begin + savepoint
- Do without releasing the savepoint immediately before commit/rollback

Commands generation separated from execution in transactions

Commands and state change are independent from sync/async. Only the
execution and the interface is in the different sync/async subclasses
now.

Define at init rather than at enter if the transaction is top-level

Refactoring to minimize sync/async savepoint duplications

Added AsyncConnection.transaction()

Anonymous savepoints represented by empty string

It makes signatures and types easier. Empty string is not valid anyway,
and bonkers types are not checked.

Connection.transaction is a context manager

It will help to avoid an async with (await conn.transaction()) on async
connections.

Dropped now redundant copy test

Added asynccontextmanager for Python 3.6

Binary copy tests enabled: now there is an int binary dumper

Copy object interface simplified

Dropped methods and code paths no more useful now that the user can only
interact with Copy as a context.

Cursor.copy() made into a context manager

What was before was a factory function, however that forced to have a
pattern like:

    async with (await cursor.copy()) as copy

Now instead what should be used is:

    async with cursor.copy() as copy

With this change the user pretty much is never exposed anymore to a Copy
object in a non-entered state. This is actually useful because it
reduces the surface of the API: now for instance Copy.finis() can become
a private method.

Dropped now redundant copy test

Added asynccontextmanager for Python 3.6

Binary copy tests enabled: now there is an int binary dumper

Copy object interface simplified

Dropped methods and code paths no more useful now that the user can only
interact with Copy as a context.

Cursor.copy() made into a context manager

What was before was a factory function, however that forced to have a
pattern like:

    async with (await cursor.copy()) as copy

Now instead what should be used is:

    async with cursor.copy() as copy

With this change the user pretty much is never exposed anymore to a Copy
object in a non-entered state. This is actually useful because it
reduces the surface of the API: now for instance Copy.finis() can become
a private method.

Escape savepoint names

Added more internal support to the connection to generate internal
commands dynamically, thanks to the `sql` module now implemented.

Transaction fixed after rebase on master

First-cut implementation of connection.transaction()

Document COPY differences and async use

Work around Py2 api of PyFloat_FromDouble in Cython

https://github.com/cython/cython/issues/3909

Better use of Python api for numeric load

Float remains to be tweaked, as affected by
https://github.com/cython/cython/issues/3909

Added C float and binary bool loaders

Simpler bool loader implementation

Trying to dump int as int8, added binary dumpers for int and float

Get oid numbers from builtins dict

Now it's accessible after it was moved to the main package.

Really update types on PostgresQuery.dump

Let's do what it says on the tin, before micro-optimising.

Docs build script path fixed

Added more documentation on COPY

Don't throw an error using COPY TO in a block

Cleanup of Copy attributes and parameters

Using generics to describe sync/async types

First cut of cursor documentation

Virtualenv to build the docs renamed to .vemv

Trigger docs build on push

Import, but don't expose, documented objects in the package.

Added support to build docs unattended

Added failing tests to remember to implement connect_timeout

More Connection documentation.

Dropped Connection.status

It is almost a synonym of closed. Will add an object to get all the info
from the connection.

More docs

Dropped Connection.pyenc and related support

Connection.client_encoding is now guaranteed to be a Python codec's
name.

Adding an embryo of documentation

Dropped use of `send()` on Connection.notifies generator

`close()` is good enough.

Allow omitting the conninfo param instead of requiring an empty string

Dropped unneeded escaping loading int from bytes

Errors and builtin oids updated to PostgreSQL 13

Added connection enter/exit

Just a simplified version, only commit/rollback + close, waiting for
nested transactions...

sql.SQL.format() accepts any Python object, making it a Literal

Load the uuid and network modules lazily

The uuid module is slow to import (was fixed in psycopg2 2.4.3, but
there is no ticket open for it). Similarly, lazy load other non-default
modules.

Fixed comments in tests

Use pytest tmpdir fixture

AsyncConnection.cursor() made async

Dropped excessive use of is [not] None

It was done with the assumption that it is faster, but it is only in
C/Cython, not in pure Python.

Dropped local variable micro-optimization

A long time ago it was a thing. timeit shows it isn't anymore.

Added TypeInfo representation

Added int subtypes to cast to specific sizes