refactor: replace 'git ls-files' + 'grep' by a single 'git grep'

chore: use Python 3.11 to conver async to sync

chore: add option to run async_to_sync in a docker image

This allows to specify which Python version to use for the conversion
(even when it's not installed on the machine).

refactor: drop 'convert_async_to_sync.sh' script

Do all in 'async_to_sync.py:' added --all and --check options.

test: drop unneeded raise on pytest.skip()

refactor(test): uniform the way sync/async-only tests are skipped

Add @skip_sync, @skip_async markers to mark the functions to skip.

test: add check to verify the completeness of convert_async_to_sync

Verify that all the files commented as having been automatically
converted are actually included in the script converting them.

style: more care in the docstring mentioning sync/async versions of the code

refactor(pool): define scheduler task as dataclass

refactor(async_to_sync): create new object without listing all the attributes

style(pool): use `pass` instead of `return` for empty methods

docs: fix typos/grammar

Co-authored-by: Daniel Fortunov <asqui@users.noreply.github.com>

refactor(copy): generate sync code from async

refactor(test): add acompat module

feat(tools): allow to specify the files to convert async to sync

fix: fix type annotation problems on Python 3.8, 3.9

refactor(pool): generate null pool module from async counterpart

refactor(pool): move null pool base to its own module

And some more light refactoring.

refactor(pool): generate pool sync module from async counterpart

refactor(pool): add Worker/AWorker type aliases

With these we don't have direct dependencies on the asyncio and
threading modules in the pool classes.

refactor(pool): give sync attribute the same life cycle of the async one

Create possibly async objects only after we are sure that a loop is
running.

refactor(pool): use non-string typing annotations

refactor(pool): add functions to get current thread/task name

The latter is only possible as we dropped support for Python 3.7.

refactor(pool): add Queue/AQueue compatibility objects

refactor(pool): add spawn/gather async compat functions

refactor(pool): add psycopg_pool._acompat to ease async/sync differences

refactor(pool): add psycopg_pool.abc module

chore: make ast-comments an ordinary dev dependency

ci: pin ast-comments to work around bug, document other bug as submitted

refactor(pool): light refactor to align async and sync pool

refactor(tests): generate null pool tests from async counterpart

refactor(tests): generate most pool tests using parametric fixture

refactor(tests): rename cursor tests to keep them together

Also rename test_default_cursor to just test_cursor as we renamed the
common tests in the previous commit.

refactor(tests): rename test_cursor to test_cursor_common

refactor(tests): generate test_pool from async counterpart

refactor(tests): generate test_sched from async counterpart

refactor(pool): generate Scheduler from AsyncScheduler

refactor: generate connection.py from connection_async

refactor(async_to_sync): finally solved the Tuple mystery

The problem came from names shadowing in the ast_comment module. To be
reported upstream.

refactor(connection): harmless manipulation to minimize async conversion diff

docs: copy connection docstrings to async class

perf(waiting): drop unneeded wait_for in wait_conn_async if no timeout is set

feat(connection): add set_autocommit() and similar methods

refactor: move BaseConnetion in its own module

This commit is brought you by: flight delayed 6 hours for technical failure.

refactor: generate cursor.py from cursor_async

docs: add docstrings from sync cursor to async

refactor: move the BaseCursor class to its own module

ci: check for inconsistencies between sync and async code

feat: add --check mode to sync-to-async script

It will be useful to set up a pipeline to check for inconsistencies.

refactor(tests): generate tpc, transaction sync tests from async

refactor(tests): make transaction sync/async tests more uniform

refactor(tests): generate sync prepared statements tests from async side

refactor(tests): auto-generate sync version of cursor subclasses

refactor(tests): auto-generate test_copy from async counterpart

refactor(tests): make test_copy and async counterpart more similar

refactor(tests): auto-generate test_client_cursor from async counterpart

refactor(tests): generate test_pipeline from async counterpart

fix(async-to-sync): fold long strings as multiline

refactor(tests): auto-generate test_connection from async

refactor(tests): make sync and async connection tests more similar

test: fix use of aclosing in Python < 3.10

refactor(tests): auto-generate the test_cursor module from async_test_cursor

Use a script to translate an async module to sync. The module is to be
extended to cover the entire test suite and then possibly the rest of
the code.

refactor(tests): tweak test_cursor to make it more similar to the async version

docs: update requirements specifiers link

docs: adjust list of supported systems.

- Mention Solaris/BSD as not officially supported.
- Drop non-GitHub macOS reference: we are now distributing Apple M1
  packages too, so that's a lie.

docs: making fun of psycopg3

For small values of fun.

docs: link together readme files on PyPI and add reference to psycopg2

See https://github.com/psycopg/psycopg2/issues/1632

docs: clean up details and errors in type annotations, more pages

chore: drop 'set -x' (commented and not) from scripts

docs(pool): simpler, less detailed, more opinionated pool docs page

Show a very basic usage example, then give a more detailed connection
life cycle illustration. Push lower and keep shorter the alternative
creation methods.

test: mark array leak test slow

It takes 300ms, but it's still a blip when other tests run.

Add notes in the tests readme about repeating finding slow tests.

refactor(pool): don't use a no-op function as reconnect callback

Just check for None.

style(pool): don't report too many decimals in timeout error message

fix(pool): trade off usage timing precision for robustness

It is unlikely that the statements we shuffled around will fail;
however, let's do the right thing and make sure that, if they do, the
getconn/putconn pair remains matched.

docs(pool): fix changelog entry

Attributing Generic pool feature entry to 3.2.0, not to 3.1.9.

Merge branch 'fix-652'

test: verify that time objects with failing utcoffset() are handled correctly

fix: raise DataError dumping a time with ambiguous timezone

Close #652

chore: drop Python 3.7 support

Also drop from the test grid PostgreSQL 10, now unsupported.

ci: add PostgreSQL 16 to the test grid

test: test Python 3.12 on all platform with final image

ci: add Python 3.12 packages build

chore: fix 'adapers' typo

style: avoid a chained traceback on dns parsing error

docs: fix typo

Merge branch 'generic-connection-pool'

docs: add docs about generic pool

feat(pool): make pool generic on connection type

chore: add typing.assert_type() to the _compat module

This requires typing_extensions >= 4.2.

fix: use Self type for connection pool in __*enter__()

This makes inheritance, e.g. for *NullConnectionPool, work correctly:

    with psycopg_pool.NullConnectionPool() as p:
        pass
    reveal_type(p)
    # Revealed type is "psycopg_pool.null_pool.NullConnectionPool"

chore: bump psycopg package version to 3.1.12

Merge branch 'fix-608'

fix: use poll() instead of epoll() for waiting

epoll() hangs when the fd it listens to is closed. poll() doesn't have
this problem (as a consequence, hanging only happened in the Python
code, as wait_c is poll-based).

fix: don't hang forever if async connection is closed while querying

Fix #608

fix: don't raise spurious errors on cancel if the connection is closed

chore(crdb): test 23.1 in CI

Merge branch 'fix-647'

fix: cache all dynamically generated adapter types

These are not currently a leak in cPython, but I don't think it's
guaranteed anywhere, and it might well not be the case in other Python
implementations. So, as a matter of hygiene, make sure that calling
register_*() in a loop doesn't create an unbound number of new types.

fix: cache dynamic adapters created in register_array()

If the base class is a C extension, the subclasses cannot be GC'd. This
results in a leak if register_array() is called in a loop.

Close #647

ci(scaleway_m1): add list command and jq pretty output