test: add gc fixtures to skip tests on PyPy more easily

chore: add support for PyPy.

Merge branch 'fix-gevent'

ci: test gevent integration

fix: ensure gevent collaboration

Close #527

test: let pytest show more info in summary

We add '-ra' to pytest options so as to get report about "(a)ll except
passed" tests. This is in particular useful to get the detailed message
about why some tests got skipped (especially useful in CI).

refactor: use `yield from` in connections attempts

Merge pull request #682 from mweinelt/clear-pg-env-when-testing-connect

test: fix test failing to connect if env vars are cleaned

Add `dsn_env` fixture returning the `dsn` merged with the values in the
PG* env vars. This way the env can be cleaned but a working connection
string is still available.

fix: flush PG environment variables in test_connect{,_args}

These tests were previously affected by environment variables, that can
be used to configure a postgresql instance.

Closes: #681

test: allow importing the tests module on master with Psycopg 3.1

Useful to test the master version of the pool with a released version of
psycopg.

chore(ci): use existing macos11 packages in macOS arm build

chore: bump psycopg package version to 3.1.13

fix: plug memory leak receiving notifications in python libpq wrapper

Close #679.

Merge pull request #675 from psycopg/fix-multiple-hosts

Fix handling of multiple hosts

chore: drop conninfo.resolve_hostaddr_async

The function is no more used internally and only exposed from the _dns
module with a warning. Its implementation is now an application of a few
internal functions exposed internally by the conninfo module. Move the
whole implementation into _dns.

fix: add support for the 'load_balance_hosts' connection parameter

test: test conninfo attempts functions and multiple host support in connection

feat: explicitly iterate on multiple hosts on connections

The libpq async connection path doesn't iterate on the attempts, so we
need to do it ourselves.

refactor: introduce support function to split connection attempts

Refactor the `resolve_hostaddr_async()` function to make use of such
facilities.

refactor: move setting autocommit on connection out of _connect_gen

chore: refresh 3rd party tests

- upgrade Python to 3.12
- test stable version of SQLAlchemy 2
- add missing SQLAlchemy test dependency

Testing Django with Python 3.12 not enabled yet as it requires pylibmc wheel
packages for Python 3.12 (https://github.com/lericson/pylibmc/issues/288).

docs(pool): document 3.1.9 as released

Packages being baked now.

Merge branch 'test-pool-3.2-psycopg-3.1'

ci: test psycopg pool package with released a psycopg version

test: allow to run pytest -m pool with psycopg 3.1 imported

This allows to test psycopg pool 3.2 tests with psycopg 3.1 installed.

chore: bump psycopg_pool package version to 3.3.0.dev1

chore: fix mypy >= 1.7 warning in tests

chore: bump psycopg_pool package version to 3.2.0

fix(bump_version): fix bumping minor version with dev releases

chore(macos): build images with more recent Python versions

Merge pull request #670 from psycopg/fix-667

Handle gracefully EINTR on signals instead of raising InterruptedError

fix: retry automatically syscall in wait_c if it fails with EINTR

Fix #667

test: add test to generate an EINTR in wait_c

Mark test_identify_closure as timing-sensitive

```
____________________________ test_identify_closure _____________________________

conn_cls = <class 'psycopg.Connection'>, dsn = 'host=127.0.0.1 user=psycopg'

    @pytest.mark.crdb_skip("pg_terminate_backend")
    @pytest.mark.slow
    def test_identify_closure(conn_cls, dsn):
        def closer():
            time.sleep(0.2)
            conn2.execute("select pg_terminate_backend(%s)", [conn.pgconn.backend_pid])

        conn = conn_cls.connect(dsn)
        conn2 = conn_cls.connect(dsn)
        try:
            t = threading.Thread(target=closer)
            t.start()
            t0 = time.time()
            try:
                with pytest.raises(psycopg.OperationalError):
                    conn.execute("select pg_sleep(1.0)")
                t1 = time.time()
>               assert 0.2 < t1 - t0 < 0.4
E               assert 0.2 < (1697715164.8614173 - 1697715164.6617775)

tests/test_concurrency.py:231: AssertionError
```

chore: use AnyIO 4.0+ in tests dependencies

We set the 'loop_factory' asyncio option for parametrizing the
anyio_backend() fixture as anyio 4.0 has replaced the 'policy' option by
'loop_factory'.

In tests/pool/test_pool_async_noasyncio.py, we previously used
the anyio_backend_options fixture to retrieve the loop policy; now we
build it directly. This could be improved by using the loop_factory, but
only from Python 3.11 with an asyncio.Runner().

refactor(pool): more logical ordering for kwargs

- conn construction params (class, kwargs, the class affects the pool
  type annotations so first is better);
- sizing (documented as an important parameter for the pool);
- open?
- callbacks (in the order they are used);
- name;
- other details more unlikely to be touched.

The order is the same in docs and code.

Merge branch 'pool-getconn-safe'

docs(pool): document check callback, drop previous recipes and rants

test(pool): add tests to verify check on getconn's behaviour

fix(pool): clean up logging in getconn check

If a check callback is set, assume that failed checks on getconn are
just part of normal operative life: don't consider them warnings.

feat(pool): add `check` connection parameter

Allow to specify a callback to call on getconn and discard the
connection if not in working state.

feat(pool): add `check_connection()` method

The method is public, will be documented as available to use as check
parameter, but also used internally by the `check()` method.

refactor(pool): introduce a loop in getconn to allow connection check

Merge branch 'pool-warn-implicit-open'

docs(pool): warn about future behaviour changes of open on init

feat(pool): raise a warning if async pools are open in the constructor

feat(pool) raise a warning if the pool is expected to be opened implicitly

refactor: define conn_encoding on pgconn_encoding

Also more consistent use of the two functions throughout the codebase.

chore: move codespell configuration to toml file

Configuration tweaked to avoid files commonly found in dev environments.

style(pool): more explicit error message for pool open with no loop

Merge branch 'async-to-sync'

Merge pull request #660 from dlax/async-to-sync

improvements to tools/async_to_sync.py

refactor: allow to use podman container engine in async_to_sync.py

feat(tools): warn about the Python version used in async-to-sync

Notify the user that they may get spurious results.

fix(tools): remove mention of dropped shell script in async_to_sync.py

refactor: use text mode for subprocess in async_to_sync.py

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