chore: drop pq enums aliases on connection and cursor

Unused in the codebase, and not documented. Only used in the test suite.

diff --git a/psycopg/psycopg/_connection_base.py b/psycopg/psycopg/_connection_base.py
index 091dc6826efc2cf7ac240da88edaae8183535eff..2d910aaa14107432523efc9c522d812ef7f13cfa 100644 (file)
--- a/psycopg/psycopg/_connection_base.py
+++ b/psycopg/psycopg/_connection_base.py
@@ -94,10 +94,6 @@ class BaseConnection(Generic[Row]):
     ProgrammingError = e.ProgrammingError
     NotSupportedError = e.NotSupportedError
 
-    # Enums useful for the connection
-    ConnStatus = pq.ConnStatus
-    TransactionStatus = pq.TransactionStatus
-
     def __init__(self, pgconn: PGconn):
         self.pgconn = pgconn
         self._autocommit = False

diff --git a/psycopg/psycopg/_cursor_base.py b/psycopg/psycopg/_cursor_base.py
index 833666bbaf98fb937474889a74c9ab2e4d68f9db..e09f17ab07d97a12887959206e4a132d71e2c670 100644 (file)
--- a/psycopg/psycopg/_cursor_base.py
+++ b/psycopg/psycopg/_cursor_base.py
@@ -51,8 +51,6 @@ class BaseCursor(Generic[ConnectionType, Row]):
         __weakref__
         """.split()
 
-    ExecStatus = pq.ExecStatus
-
     _tx: Transformer
     _make_row: RowMaker[Row]
     _pgconn: PGconn

diff --git a/tests/_test_copy.py b/tests/_test_copy.py
index 4ee9ee5f9b27dc1624ee89815c076ebf4647a004..54bf08ff8dc7360292605fb5e56616f088dd6bda 100644 (file)
--- a/tests/_test_copy.py
+++ b/tests/_test_copy.py
@@ -1,6 +1,6 @@
 import struct
 
-from psycopg.pq import Format
+from psycopg import pq
 from psycopg.copy import AsyncWriter
 from psycopg.copy import FileWriter as FileWriter  # noqa: F401
 
@@ -43,7 +43,7 @@ async def ensure_table_async(cur, tabledef, name="copy_in"):
 
 def py_to_raw(item, fmt):
     """Convert from Python type to the expected result from the db"""
-    if fmt == Format.TEXT:
+    if fmt == pq.Format.TEXT:
         if isinstance(item, int):
             return str(item)
     else:

diff --git a/tests/_test_transaction.py b/tests/_test_transaction.py
index 29e7ad70d77ffd76d845957a2008fa2a03b7474e..27618e5fe06b117e2b26c70dfdd757cc0e76bf1b 100644 (file)
--- a/tests/_test_transaction.py
+++ b/tests/_test_transaction.py
@@ -1,6 +1,7 @@
 import sys
 import pytest
 import psycopg
+from psycopg import pq
 
 
 # TODOCRDB: is this the expected behaviour?
@@ -50,9 +51,9 @@ def inserted(conn):
 
 
 def in_transaction(conn):
-    if conn.pgconn.transaction_status == conn.TransactionStatus.IDLE:
+    if conn.pgconn.transaction_status == pq.TransactionStatus.IDLE:
         return False
-    elif conn.pgconn.transaction_status == conn.TransactionStatus.INTRANS:
+    elif conn.pgconn.transaction_status == pq.TransactionStatus.INTRANS:
         return True
     else:
         assert False, conn.pgconn.transaction_status

diff --git a/tests/crdb/test_copy.py b/tests/crdb/test_copy.py
index 8c09fea84af0dedbaf31db3ecb1d38a6ee485623..8670227d9d41b3b2e52537058f6113c0ff539078 100644 (file)
--- a/tests/crdb/test_copy.py
+++ b/tests/crdb/test_copy.py
@@ -6,8 +6,7 @@ import string
 from random import randrange, choice
 from typing import Any  # noqa: ignore
 
-from psycopg import sql, errors as e
-from psycopg.pq import Format
+from psycopg import pq, sql, errors as e
 from psycopg.adapt import PyFormat
 from psycopg.types.numeric import Int4
 
@@ -23,7 +22,8 @@ pytestmark = [pytest.mark.crdb]
 
 
 @pytest.mark.parametrize(
-    "format, buffer", [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")]
+    "format, buffer",
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 def test_copy_in_buffers(conn, format, buffer):
     cur = conn.cursor()
@@ -43,7 +43,7 @@ def test_copy_in_buffers_pg_error(conn):
         with cur.copy("copy copy_in from stdin") as copy:
             copy.write(sample_text)
             copy.write(sample_text)
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 def test_copy_in_str(conn):
@@ -65,17 +65,17 @@ def test_copy_in_error(conn):
         with cur.copy("copy copy_in from stdin with binary") as copy:
             copy.write(sample_text.decode())
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_in_empty(conn, format):
     cur = conn.cursor()
     ensure_table(cur, sample_tabledef)
     with cur.copy(f"copy copy_in from stdin {copyopt(format)}"):
         pass
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.info.transaction_status == pq.TransactionStatus.INTRANS
     assert cur.rowcount == 0
 
 
@@ -112,10 +112,10 @@ def test_copy_in_buffers_with_pg_error(conn):
             copy.write(sample_text)
             copy.write(sample_text)
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_in_records(conn, format):
     cur = conn.cursor()
     ensure_table(cur, sample_tabledef)
@@ -123,7 +123,7 @@ def test_copy_in_records(conn, format):
     with cur.copy(f"copy copy_in from stdin {copyopt(format)}") as copy:
         row: "tuple[Any, ...]"
         for row in sample_records:
-            if format == Format.BINARY:
+            if format == pq.Format.BINARY:
                 row = tuple((Int4(i) if isinstance(i, int) else i for i in row))
             copy.write_row(row)
 
@@ -132,7 +132,7 @@ def test_copy_in_records(conn, format):
     assert data == sample_records
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_in_records_set_types(conn, format):
     cur = conn.cursor()
     ensure_table(cur, sample_tabledef)
@@ -147,7 +147,7 @@ def test_copy_in_records_set_types(conn, format):
     assert data == sample_records
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_in_records_binary(conn, format):
     cur = conn.cursor()
     ensure_table(cur, "col1 serial primary key, col2 int4, data text")
@@ -171,7 +171,7 @@ def test_copy_in_buffers_with_py_error(conn):
             raise Exception("nuttengoggenio")
 
     assert "nuttengoggenio" in str(exc.value)
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 def test_copy_in_allchars(conn):
@@ -195,7 +195,8 @@ from copy_in group by 1, 2, 3
 
 @pytest.mark.slow
 @pytest.mark.parametrize(
-    "fmt, set_types", [(Format.TEXT, True), (Format.TEXT, False), (Format.BINARY, True)]
+    "fmt, set_types",
+    [(pq.Format.TEXT, True), (pq.Format.TEXT, False), (pq.Format.BINARY, True)],
 )
 @pytest.mark.crdb_skip("copy array")
 def test_copy_from_leaks(conn_cls, dsn, faker, fmt, set_types, gc):
@@ -237,4 +238,4 @@ def test_copy_from_leaks(conn_cls, dsn, faker, fmt, set_types, gc):
 
 
 def copyopt(format):
-    return "with binary" if format == Format.BINARY else ""
+    return "with binary" if format == pq.Format.BINARY else ""

diff --git a/tests/crdb/test_copy_async.py b/tests/crdb/test_copy_async.py
index 1199e3a7b58a3fa6d779201a54ca7cda6f688372..9880f6fe476e13c9ae0242b0e7506d690668a3fc 100644 (file)
--- a/tests/crdb/test_copy_async.py
+++ b/tests/crdb/test_copy_async.py
@@ -3,8 +3,7 @@ import string
 from random import randrange, choice
 from typing import Any  # noqa: ignore
 
-from psycopg import sql, errors as e
-from psycopg.pq import Format
+from psycopg import pq, sql, errors as e
 from psycopg.adapt import PyFormat
 from psycopg.types.numeric import Int4
 
@@ -23,7 +22,7 @@ if True:  # ASYNC
 
 @pytest.mark.parametrize(
     "format, buffer",
-    [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")],
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 async def test_copy_in_buffers(aconn, format, buffer):
     cur = aconn.cursor()
@@ -43,7 +42,7 @@ async def test_copy_in_buffers_pg_error(aconn):
         async with cur.copy("copy copy_in from stdin") as copy:
             await copy.write(sample_text)
             await copy.write(sample_text)
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 async def test_copy_in_str(aconn):
@@ -65,17 +64,17 @@ async def test_copy_in_error(aconn):
         async with cur.copy("copy copy_in from stdin with binary") as copy:
             await copy.write(sample_text.decode())
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_in_empty(aconn, format):
     cur = aconn.cursor()
     await ensure_table_async(cur, sample_tabledef)
     async with cur.copy(f"copy copy_in from stdin {copyopt(format)}"):
         pass
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.info.transaction_status == pq.TransactionStatus.INTRANS
     assert cur.rowcount == 0
 
 
@@ -112,10 +111,10 @@ async def test_copy_in_buffers_with_pg_error(aconn):
             await copy.write(sample_text)
             await copy.write(sample_text)
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_in_records(aconn, format):
     cur = aconn.cursor()
     await ensure_table_async(cur, sample_tabledef)
@@ -123,7 +122,7 @@ async def test_copy_in_records(aconn, format):
     async with cur.copy(f"copy copy_in from stdin {copyopt(format)}") as copy:
         row: "tuple[Any, ...]"
         for row in sample_records:
-            if format == Format.BINARY:
+            if format == pq.Format.BINARY:
                 row = tuple(Int4(i) if isinstance(i, int) else i for i in row)
             await copy.write_row(row)
 
@@ -132,7 +131,7 @@ async def test_copy_in_records(aconn, format):
     assert data == sample_records
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_in_records_set_types(aconn, format):
     cur = aconn.cursor()
     await ensure_table_async(cur, sample_tabledef)
@@ -147,7 +146,7 @@ async def test_copy_in_records_set_types(aconn, format):
     assert data == sample_records
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_in_records_binary(aconn, format):
     cur = aconn.cursor()
     await ensure_table_async(cur, "col1 serial primary key, col2 int4, data text")
@@ -173,7 +172,7 @@ async def test_copy_in_buffers_with_py_error(aconn):
             raise Exception("nuttengoggenio")
 
     assert "nuttengoggenio" in str(exc.value)
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 async def test_copy_in_allchars(aconn):
@@ -198,7 +197,7 @@ from copy_in group by 1, 2, 3
 @pytest.mark.slow
 @pytest.mark.parametrize(
     "fmt, set_types",
-    [(Format.TEXT, True), (Format.TEXT, False), (Format.BINARY, True)],
+    [(pq.Format.TEXT, True), (pq.Format.TEXT, False), (pq.Format.BINARY, True)],
 )
 @pytest.mark.crdb_skip("copy array")
 async def test_copy_from_leaks(aconn_cls, dsn, faker, fmt, set_types, gc):
@@ -240,4 +239,4 @@ async def test_copy_from_leaks(aconn_cls, dsn, faker, fmt, set_types, gc):
 
 
 def copyopt(format):
-    return "with binary" if format == Format.BINARY else ""
+    return "with binary" if format == pq.Format.BINARY else ""

diff --git a/tests/crdb/test_cursor.py b/tests/crdb/test_cursor.py
index 3ba0a9f7c142c34e436d255105ed81b48aedd34f..443addc9dad040519cc8b2414699a0928f524e97 100644 (file)
--- a/tests/crdb/test_cursor.py
+++ b/tests/crdb/test_cursor.py
@@ -37,7 +37,7 @@ def test_changefeed(conn_cls, dsn, conn, testfeed, fmt_out):
                     for row in cur.stream(f"experimental changefeed for {testfeed}"):
                         q.put_nowait(row)
                 except e.QueryCanceled:
-                    assert conn.info.transaction_status == conn.TransactionStatus.IDLE
+                    assert conn.info.transaction_status == pq.TransactionStatus.IDLE
                     q.put_nowait(None)
         except Exception as ex:
             q.put_nowait(ex)

diff --git a/tests/crdb/test_cursor_async.py b/tests/crdb/test_cursor_async.py
index c7848160146f1dd4fe9c2a7ef0b1a4c4c4fea278..0607c770855cca531fed3dbd71cc925e301df79f 100644 (file)
--- a/tests/crdb/test_cursor_async.py
+++ b/tests/crdb/test_cursor_async.py
@@ -38,7 +38,7 @@ async def test_changefeed(aconn_cls, dsn, aconn, testfeed, fmt_out):
                     ):
                         q.put_nowait(row)
                 except e.QueryCanceled:
-                    assert conn.info.transaction_status == conn.TransactionStatus.IDLE
+                    assert conn.info.transaction_status == pq.TransactionStatus.IDLE
                     q.put_nowait(None)
         except Exception as ex:
             q.put_nowait(ex)

diff --git a/tests/test_connection.py b/tests/test_connection.py
index cb4fe7e1fc1ee9d543ec46269b7889a05e3a0714..c8b6a0c4eb71cb2fe9ab63ff457f434f004143a0 100644 (file)
--- a/tests/test_connection.py
+++ b/tests/test_connection.py
@@ -26,7 +26,7 @@ from .test_adapt import make_bin_dumper, make_dumper
 def test_connect(conn_cls, dsn):
     conn = conn_cls.connect(dsn)
     assert not conn.closed
-    assert conn.pgconn.status == conn.ConnStatus.OK
+    assert conn.pgconn.status == pq.ConnStatus.OK
     conn.close()
 
 
@@ -42,7 +42,7 @@ def test_connect_str_subclass(conn_cls, dsn):
 
     conn = conn_cls.connect(MyString(dsn))
     assert not conn.closed
-    assert conn.pgconn.status == conn.ConnStatus.OK
+    assert conn.pgconn.status == pq.ConnStatus.OK
     conn.close()
 
 
@@ -100,11 +100,11 @@ def test_close(conn):
     conn.close()
     assert conn.closed
     assert not conn.broken
-    assert conn.pgconn.status == conn.ConnStatus.BAD
+    assert conn.pgconn.status == pq.ConnStatus.BAD
 
     conn.close()
     assert conn.closed
-    assert conn.pgconn.status == conn.ConnStatus.BAD
+    assert conn.pgconn.status == pq.ConnStatus.BAD
 
     with pytest.raises(psycopg.OperationalError):
         cur.execute("select 1")
@@ -240,7 +240,7 @@ def test_context_active_rollback_no_clobber(conn_cls, dsn, caplog):
             conn.pgconn.exec_(b"copy (select generate_series(1, 10)) to stdout")
             assert not conn.pgconn.error_message
             status = conn.info.transaction_status
-            assert status == conn.TransactionStatus.ACTIVE
+            assert status == pq.TransactionStatus.ACTIVE
             1 / 0
 
     assert len(caplog.records) == 1
@@ -263,10 +263,10 @@ def test_commit(conn):
     conn.pgconn.exec_(b"drop table if exists foo")
     conn.pgconn.exec_(b"create table foo (id int primary key)")
     conn.pgconn.exec_(b"begin")
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
     conn.pgconn.exec_(b"insert into foo values (1)")
     conn.commit()
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     res = conn.pgconn.exec_(b"select id from foo where id = 1")
     assert res.get_value(0, 0) == b"1"
 
@@ -290,7 +290,7 @@ def test_commit_error(conn):
     conn.execute("insert into selfref (y) values (-1)")
     with pytest.raises(e.ForeignKeyViolation):
         conn.commit()
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     cur = conn.execute("select 1")
     assert cur.fetchone() == (1,)
 
@@ -299,10 +299,10 @@ def test_rollback(conn):
     conn.pgconn.exec_(b"drop table if exists foo")
     conn.pgconn.exec_(b"create table foo (id int primary key)")
     conn.pgconn.exec_(b"begin")
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
     conn.pgconn.exec_(b"insert into foo values (1)")
     conn.rollback()
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     res = conn.pgconn.exec_(b"select id from foo where id = 1")
     assert res.ntuples == 0
 
@@ -316,16 +316,16 @@ def test_auto_transaction(conn):
     conn.pgconn.exec_(b"create table foo (id int primary key)")
 
     cur = conn.cursor()
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
 
     cur.execute("insert into foo values (1)")
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
 
     conn.commit()
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     cur.execute("select * from foo")
     assert cur.fetchone() == (1,)
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
 
 
 def test_auto_transaction_fail(conn):
@@ -333,23 +333,23 @@ def test_auto_transaction_fail(conn):
     conn.pgconn.exec_(b"create table foo (id int primary key)")
 
     cur = conn.cursor()
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
 
     cur.execute("insert into foo values (1)")
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
 
     with pytest.raises(psycopg.DatabaseError):
         cur.execute("meh")
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.INERROR
 
     with pytest.raises(psycopg.errors.InFailedSqlTransaction):
         cur.execute("select 1")
 
     conn.commit()
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     cur.execute("select * from foo")
     assert cur.fetchone() is None
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
 
 
 @skip_sync
@@ -366,7 +366,7 @@ def test_autocommit(conn):
     cur = conn.cursor()
     cur.execute("select 1")
     assert cur.fetchone() == (1,)
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
 
     conn.set_autocommit("")
     assert isinstance(conn.autocommit, bool)
@@ -386,7 +386,7 @@ def test_autocommit_property(conn):
     cur = conn.cursor()
     cur.execute("select 1")
     assert cur.fetchone() == (1,)
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
 
     conn.autocommit = ""
     assert isinstance(conn.autocommit, bool)
@@ -407,7 +407,7 @@ def test_autocommit_intrans(conn):
     cur = conn.cursor()
     cur.execute("select 1")
     assert cur.fetchone() == (1,)
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
     with pytest.raises(psycopg.ProgrammingError):
         conn.set_autocommit(True)
     assert not conn.autocommit
@@ -417,7 +417,7 @@ def test_autocommit_inerror(conn):
     cur = conn.cursor()
     with pytest.raises(psycopg.DatabaseError):
         cur.execute("meh")
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.INERROR
     with pytest.raises(psycopg.ProgrammingError):
         conn.set_autocommit(True)
     assert not conn.autocommit
@@ -425,7 +425,7 @@ def test_autocommit_inerror(conn):
 
 def test_autocommit_unknown(conn):
     conn.close()
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.UNKNOWN
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.UNKNOWN
     with pytest.raises(psycopg.OperationalError):
         conn.set_autocommit(True)
     assert not conn.autocommit

diff --git a/tests/test_connection_async.py b/tests/test_connection_async.py
index 8a4984af3d59cc9af05765bad54a16d9033cb906..b0836fdf8474d9a376507e215c985fdb28961bc6 100644 (file)
--- a/tests/test_connection_async.py
+++ b/tests/test_connection_async.py
@@ -23,7 +23,7 @@ from .test_adapt import make_bin_dumper, make_dumper
 async def test_connect(aconn_cls, dsn):
     conn = await aconn_cls.connect(dsn)
     assert not conn.closed
-    assert conn.pgconn.status == conn.ConnStatus.OK
+    assert conn.pgconn.status == pq.ConnStatus.OK
     await conn.close()
 
 
@@ -38,7 +38,7 @@ async def test_connect_str_subclass(aconn_cls, dsn):
 
     conn = await aconn_cls.connect(MyString(dsn))
     assert not conn.closed
-    assert conn.pgconn.status == conn.ConnStatus.OK
+    assert conn.pgconn.status == pq.ConnStatus.OK
     await conn.close()
 
 
@@ -96,11 +96,11 @@ async def test_close(aconn):
     await aconn.close()
     assert aconn.closed
     assert not aconn.broken
-    assert aconn.pgconn.status == aconn.ConnStatus.BAD
+    assert aconn.pgconn.status == pq.ConnStatus.BAD
 
     await aconn.close()
     assert aconn.closed
-    assert aconn.pgconn.status == aconn.ConnStatus.BAD
+    assert aconn.pgconn.status == pq.ConnStatus.BAD
 
     with pytest.raises(psycopg.OperationalError):
         await cur.execute("select 1")
@@ -237,7 +237,7 @@ async def test_context_active_rollback_no_clobber(aconn_cls, dsn, caplog):
             conn.pgconn.exec_(b"copy (select generate_series(1, 10)) to stdout")
             assert not conn.pgconn.error_message
             status = conn.info.transaction_status
-            assert status == conn.TransactionStatus.ACTIVE
+            assert status == pq.TransactionStatus.ACTIVE
             1 / 0
 
     assert len(caplog.records) == 1
@@ -260,10 +260,10 @@ async def test_commit(aconn):
     aconn.pgconn.exec_(b"drop table if exists foo")
     aconn.pgconn.exec_(b"create table foo (id int primary key)")
     aconn.pgconn.exec_(b"begin")
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
     aconn.pgconn.exec_(b"insert into foo values (1)")
     await aconn.commit()
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     res = aconn.pgconn.exec_(b"select id from foo where id = 1")
     assert res.get_value(0, 0) == b"1"
 
@@ -287,7 +287,7 @@ async def test_commit_error(aconn):
     await aconn.execute("insert into selfref (y) values (-1)")
     with pytest.raises(e.ForeignKeyViolation):
         await aconn.commit()
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     cur = await aconn.execute("select 1")
     assert await cur.fetchone() == (1,)
 
@@ -296,10 +296,10 @@ async def test_rollback(aconn):
     aconn.pgconn.exec_(b"drop table if exists foo")
     aconn.pgconn.exec_(b"create table foo (id int primary key)")
     aconn.pgconn.exec_(b"begin")
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
     aconn.pgconn.exec_(b"insert into foo values (1)")
     await aconn.rollback()
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     res = aconn.pgconn.exec_(b"select id from foo where id = 1")
     assert res.ntuples == 0
 
@@ -313,16 +313,16 @@ async def test_auto_transaction(aconn):
     aconn.pgconn.exec_(b"create table foo (id int primary key)")
 
     cur = aconn.cursor()
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.IDLE
 
     await cur.execute("insert into foo values (1)")
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
 
     await aconn.commit()
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     await cur.execute("select * from foo")
     assert await cur.fetchone() == (1,)
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
 
 
 async def test_auto_transaction_fail(aconn):
@@ -330,23 +330,23 @@ async def test_auto_transaction_fail(aconn):
     aconn.pgconn.exec_(b"create table foo (id int primary key)")
 
     cur = aconn.cursor()
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.IDLE
 
     await cur.execute("insert into foo values (1)")
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
 
     with pytest.raises(psycopg.DatabaseError):
         await cur.execute("meh")
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.INERROR
 
     with pytest.raises(psycopg.errors.InFailedSqlTransaction):
         await cur.execute("select 1")
 
     await aconn.commit()
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.IDLE
     await cur.execute("select * from foo")
     assert await cur.fetchone() is None
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
 
 
 @skip_sync
@@ -363,7 +363,7 @@ async def test_autocommit(aconn):
     cur = aconn.cursor()
     await cur.execute("select 1")
     assert await cur.fetchone() == (1,)
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.IDLE
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.IDLE
 
     await aconn.set_autocommit("")
     assert isinstance(aconn.autocommit, bool)
@@ -383,7 +383,7 @@ def test_autocommit_property(conn):
     cur = conn.cursor()
     cur.execute("select 1")
     assert cur.fetchone() == (1,)
-    assert conn.pgconn.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.pgconn.transaction_status == pq.TransactionStatus.IDLE
 
     conn.autocommit = ""
     assert isinstance(conn.autocommit, bool)
@@ -404,7 +404,7 @@ async def test_autocommit_intrans(aconn):
     cur = aconn.cursor()
     await cur.execute("select 1")
     assert await cur.fetchone() == (1,)
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.INTRANS
     with pytest.raises(psycopg.ProgrammingError):
         await aconn.set_autocommit(True)
     assert not aconn.autocommit
@@ -414,7 +414,7 @@ async def test_autocommit_inerror(aconn):
     cur = aconn.cursor()
     with pytest.raises(psycopg.DatabaseError):
         await cur.execute("meh")
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.INERROR
     with pytest.raises(psycopg.ProgrammingError):
         await aconn.set_autocommit(True)
     assert not aconn.autocommit
@@ -422,7 +422,7 @@ async def test_autocommit_inerror(aconn):
 
 async def test_autocommit_unknown(aconn):
     await aconn.close()
-    assert aconn.pgconn.transaction_status == aconn.TransactionStatus.UNKNOWN
+    assert aconn.pgconn.transaction_status == pq.TransactionStatus.UNKNOWN
     with pytest.raises(psycopg.OperationalError):
         await aconn.set_autocommit(True)
     assert not aconn.autocommit

diff --git a/tests/test_copy.py b/tests/test_copy.py
index 3abe9bfa1aec26bd774a186b29914de43377f923..642917e8c3f362536a18f476856250841b92db70 100644 (file)
--- a/tests/test_copy.py
+++ b/tests/test_copy.py
@@ -10,10 +10,7 @@ from itertools import cycle
 import pytest
 
 import psycopg
-from psycopg import pq
-from psycopg import sql
-from psycopg import errors as e
-from psycopg.pq import Format
+from psycopg import pq, sql, errors as e
 from psycopg.copy import Copy, LibpqWriter, QueuedLibpqWriter
 from psycopg.adapt import PyFormat
 from psycopg.types import TypeInfo
@@ -29,7 +26,7 @@ from .test_adapt import StrNoneDumper, StrNoneBinaryDumper
 pytestmark = pytest.mark.crdb_skip("copy")
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_out_read(conn, format):
     if format == pq.Format.TEXT:
         want = [row + b"\n" for row in sample_text.splitlines()]
@@ -41,16 +38,16 @@ def test_copy_out_read(conn, format):
         for row in want:
             got = copy.read()
             assert got == row
-            assert conn.info.transaction_status == conn.TransactionStatus.ACTIVE
+            assert conn.info.transaction_status == pq.TransactionStatus.ACTIVE
 
         assert copy.read() == b""
         assert copy.read() == b""
 
     assert copy.read() == b""
-    assert conn.info.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 @pytest.mark.parametrize("row_factory", ["tuple_row", "dict_row", "namedtuple_row"])
 def test_copy_out_iter(conn, format, row_factory):
     if format == pq.Format.TEXT:
@@ -63,10 +60,10 @@ def test_copy_out_iter(conn, format, row_factory):
     with cur.copy(f"copy ({sample_values}) to stdout (format {format.name})") as copy:
         assert list(copy) == want
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 @pytest.mark.parametrize("row_factory", ["tuple_row", "dict_row", "namedtuple_row"])
 def test_copy_out_no_result(conn, format, row_factory):
     rf = getattr(psycopg.rows, row_factory)
@@ -85,10 +82,10 @@ def test_copy_out_param(conn, ph, params):
         copy.set_types(["int4"])
         assert list(copy.rows()) == [(i + 1,) for i in range(10)]
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 @pytest.mark.parametrize("typetype", ["names", "oids"])
 def test_read_rows(conn, format, typetype):
     cur = conn.cursor()
@@ -103,10 +100,10 @@ def test_read_rows(conn, format, typetype):
         assert copy.read_row() is None
 
     assert row == (10, "hello", [0.0, 1.0])
-    assert conn.info.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_rows(conn, format):
     cur = conn.cursor()
     with cur.copy(f"copy ({sample_values}) to stdout (format {format.name})") as copy:
@@ -114,7 +111,7 @@ def test_rows(conn, format):
         rows = list(copy.rows())
 
     assert rows == sample_records
-    assert conn.info.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
 def test_set_custom_type(conn, hstore):
@@ -134,7 +131,7 @@ def test_set_custom_type(conn, hstore):
     assert rows == [({"a": "1", "b": "2"},)]
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_out_allchars(conn, format):
     cur = conn.cursor()
     chars = list(map(chr, range(1, 256))) + [eur]
@@ -155,7 +152,7 @@ def test_copy_out_allchars(conn, format):
     assert rows == chars
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_read_row_notypes(conn, format):
     cur = conn.cursor()
     with cur.copy(f"copy ({sample_values}) to stdout (format {format.name})") as copy:
@@ -170,7 +167,7 @@ def test_read_row_notypes(conn, format):
     assert rows == ref
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_rows_notypes(conn, format):
     cur = conn.cursor()
     with cur.copy(f"copy ({sample_values}) to stdout (format {format.name})") as copy:
@@ -180,7 +177,7 @@ def test_rows_notypes(conn, format):
 
 
 @pytest.mark.parametrize("err", [-1, 1])
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_out_badntypes(conn, format, err):
     cur = conn.cursor()
     with cur.copy(f"copy ({sample_values}) to stdout (format {format.name})") as copy:
@@ -190,7 +187,8 @@ def test_copy_out_badntypes(conn, format, err):
 
 
 @pytest.mark.parametrize(
-    "format, buffer", [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")]
+    "format, buffer",
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 def test_copy_in_buffers(conn, format, buffer):
     cur = conn.cursor()
@@ -210,7 +208,7 @@ def test_copy_in_buffers_pg_error(conn):
         with cur.copy("copy copy_in from stdin (format text)") as copy:
             copy.write(sample_text)
             copy.write(sample_text)
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 def test_copy_bad_result(conn):
@@ -257,17 +255,17 @@ def test_copy_in_error(conn):
         with cur.copy("copy copy_in from stdin (format binary)") as copy:
             copy.write(sample_text.decode())
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_in_empty(conn, format):
     cur = conn.cursor()
     ensure_table(cur, sample_tabledef)
     with cur.copy(f"copy copy_in from stdin (format {format.name})"):
         pass
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.info.transaction_status == pq.TransactionStatus.INTRANS
     assert cur.rowcount == 0
 
 
@@ -297,9 +295,9 @@ def test_copy_big_size_block(conn, pytype):
     assert cur.fetchone() == (data,)
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_subclass_adapter(conn, format):
-    if format == Format.TEXT:
+    if format == pq.Format.TEXT:
         from psycopg.types.string import StrDumper as BaseDumper
     else:
         from psycopg.types.string import StrBinaryDumper
@@ -326,9 +324,9 @@ def test_subclass_adapter(conn, format):
     assert rec[0] == "hellohello"
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_subclass_nulling_dumper(conn, format):
-    Base: type = StrNoneDumper if format == Format.TEXT else StrNoneBinaryDumper
+    Base: type = StrNoneDumper if format == pq.Format.TEXT else StrNoneBinaryDumper
 
     class MyStrDumper(Base):  # type: ignore
 
@@ -349,7 +347,7 @@ def test_subclass_nulling_dumper(conn, format):
     assert recs == [("hello",), (None,)]
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_in_error_empty(conn, format):
     cur = conn.cursor()
     ensure_table(cur, sample_tabledef)
@@ -357,7 +355,7 @@ def test_copy_in_error_empty(conn, format):
         with cur.copy(f"copy copy_in from stdin (format {format.name})"):
             raise ZeroDivisionError("mannaggiamiseria")
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 def test_copy_in_buffers_with_pg_error(conn):
@@ -368,7 +366,7 @@ def test_copy_in_buffers_with_pg_error(conn):
             copy.write(sample_text)
             copy.write(sample_text)
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 def test_copy_in_buffers_with_py_error(conn):
@@ -379,7 +377,7 @@ def test_copy_in_buffers_with_py_error(conn):
             copy.write(sample_text)
             raise ZeroDivisionError("nuttengoggenio")
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 def test_copy_out_error_with_copy_finished(conn):
@@ -389,7 +387,7 @@ def test_copy_out_error_with_copy_finished(conn):
             copy.read_row()
             1 / 0
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
 def test_copy_out_error_with_copy_not_finished(conn):
@@ -399,7 +397,7 @@ def test_copy_out_error_with_copy_not_finished(conn):
             copy.read_row()
             1 / 0
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 def test_copy_out_server_error(conn):
@@ -411,17 +409,17 @@ def test_copy_out_server_error(conn):
             for block in copy:
                 pass
 
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_in_records(conn, format):
     cur = conn.cursor()
     ensure_table(cur, sample_tabledef)
 
     with cur.copy(f"copy copy_in from stdin (format {format.name})") as copy:
         for row in sample_records:
-            if format == Format.BINARY:
+            if format == pq.Format.BINARY:
                 row2 = tuple((Int4(i) if isinstance(i, int) else i for i in row))
                 row = row2  # type: ignore[assignment]
             copy.write_row(row)
@@ -431,7 +429,7 @@ def test_copy_in_records(conn, format):
     assert data == sample_records
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_in_records_set_types(conn, format):
     cur = conn.cursor()
     ensure_table(cur, sample_tabledef)
@@ -446,7 +444,7 @@ def test_copy_in_records_set_types(conn, format):
     assert data == sample_records
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 def test_copy_in_records_binary(conn, format):
     cur = conn.cursor()
     ensure_table(cur, "col1 serial primary key, col2 int, data text")
@@ -506,7 +504,8 @@ def test_copy_in_format(conn):
 
 
 @pytest.mark.parametrize(
-    "format, buffer", [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")]
+    "format, buffer",
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 def test_file_writer(conn, format, buffer):
     file = BytesIO()
@@ -649,7 +648,8 @@ def test_description(conn):
 
 
 @pytest.mark.parametrize(
-    "format, buffer", [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")]
+    "format, buffer",
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 def test_worker_life(conn, format, buffer):
     cur = conn.cursor()
@@ -682,7 +682,8 @@ def test_worker_error_propagated(conn, monkeypatch):
 
 
 @pytest.mark.parametrize(
-    "format, buffer", [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")]
+    "format, buffer",
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 def test_connection_writer(conn, format, buffer):
     cur = conn.cursor()
@@ -702,7 +703,8 @@ def test_connection_writer(conn, format, buffer):
 
 @pytest.mark.slow
 @pytest.mark.parametrize(
-    "fmt, set_types", [(Format.TEXT, True), (Format.TEXT, False), (Format.BINARY, True)]
+    "fmt, set_types",
+    [(pq.Format.TEXT, True), (pq.Format.TEXT, False), (pq.Format.BINARY, True)],
 )
 @pytest.mark.parametrize("method", ["read", "iter", "row", "rows"])
 def test_copy_to_leaks(conn_cls, dsn, faker, fmt, set_types, method, gc):
@@ -757,7 +759,8 @@ def test_copy_to_leaks(conn_cls, dsn, faker, fmt, set_types, method, gc):
 
 @pytest.mark.slow
 @pytest.mark.parametrize(
-    "fmt, set_types", [(Format.TEXT, True), (Format.TEXT, False), (Format.BINARY, True)]
+    "fmt, set_types",
+    [(pq.Format.TEXT, True), (pq.Format.TEXT, False), (pq.Format.BINARY, True)],
 )
 def test_copy_from_leaks(conn_cls, dsn, faker, fmt, set_types, gc):
     faker.format = PyFormat.from_pq(fmt)

diff --git a/tests/test_copy_async.py b/tests/test_copy_async.py
index b0f48458e8bbc2ba8f36effeef1b8cc157dd0262..a4c15dba82709c0399004f479aff8bae8fe8a733 100644 (file)
--- a/tests/test_copy_async.py
+++ b/tests/test_copy_async.py
@@ -7,10 +7,7 @@ from itertools import cycle
 import pytest
 
 import psycopg
-from psycopg import pq
-from psycopg import sql
-from psycopg import errors as e
-from psycopg.pq import Format
+from psycopg import pq, sql, errors as e
 from psycopg.copy import AsyncCopy, AsyncLibpqWriter, AsyncQueuedLibpqWriter
 from psycopg.adapt import PyFormat
 from psycopg.types import TypeInfo
@@ -27,7 +24,7 @@ from .test_adapt import StrNoneDumper, StrNoneBinaryDumper
 pytestmark = pytest.mark.crdb_skip("copy")
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_out_read(aconn, format):
     if format == pq.Format.TEXT:
         want = [row + b"\n" for row in sample_text.splitlines()]
@@ -41,16 +38,16 @@ async def test_copy_out_read(aconn, format):
         for row in want:
             got = await copy.read()
             assert got == row
-            assert aconn.info.transaction_status == aconn.TransactionStatus.ACTIVE
+            assert aconn.info.transaction_status == pq.TransactionStatus.ACTIVE
 
         assert await copy.read() == b""
         assert await copy.read() == b""
 
     assert await copy.read() == b""
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 @pytest.mark.parametrize("row_factory", ["tuple_row", "dict_row", "namedtuple_row"])
 async def test_copy_out_iter(aconn, format, row_factory):
     if format == pq.Format.TEXT:
@@ -65,10 +62,10 @@ async def test_copy_out_iter(aconn, format, row_factory):
     ) as copy:
         assert await alist(copy) == want
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 @pytest.mark.parametrize("row_factory", ["tuple_row", "dict_row", "namedtuple_row"])
 async def test_copy_out_no_result(aconn, format, row_factory):
     rf = getattr(psycopg.rows, row_factory)
@@ -87,10 +84,10 @@ async def test_copy_out_param(aconn, ph, params):
         copy.set_types(["int4"])
         assert await alist(copy.rows()) == [(i + 1,) for i in range(10)]
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 @pytest.mark.parametrize("typetype", ["names", "oids"])
 async def test_read_rows(aconn, format, typetype):
     cur = aconn.cursor()
@@ -105,10 +102,10 @@ async def test_read_rows(aconn, format, typetype):
         assert (await copy.read_row()) is None
 
     assert row == (10, "hello", [0.0, 1.0])
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_rows(aconn, format):
     cur = aconn.cursor()
     async with cur.copy(
@@ -118,7 +115,7 @@ async def test_rows(aconn, format):
         rows = await alist(copy.rows())
 
     assert rows == sample_records
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
 async def test_set_custom_type(aconn, hstore):
@@ -138,7 +135,7 @@ async def test_set_custom_type(aconn, hstore):
     assert rows == [({"a": "1", "b": "2"},)]
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_out_allchars(aconn, format):
     cur = aconn.cursor()
     chars = list(map(chr, range(1, 256))) + [eur]
@@ -159,7 +156,7 @@ async def test_copy_out_allchars(aconn, format):
     assert rows == chars
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_read_row_notypes(aconn, format):
     cur = aconn.cursor()
     async with cur.copy(
@@ -176,7 +173,7 @@ async def test_read_row_notypes(aconn, format):
     assert rows == ref
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_rows_notypes(aconn, format):
     cur = aconn.cursor()
     async with cur.copy(
@@ -188,7 +185,7 @@ async def test_rows_notypes(aconn, format):
 
 
 @pytest.mark.parametrize("err", [-1, 1])
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_out_badntypes(aconn, format, err):
     cur = aconn.cursor()
     async with cur.copy(
@@ -200,7 +197,8 @@ async def test_copy_out_badntypes(aconn, format, err):
 
 
 @pytest.mark.parametrize(
-    "format, buffer", [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")]
+    "format, buffer",
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 async def test_copy_in_buffers(aconn, format, buffer):
     cur = aconn.cursor()
@@ -220,7 +218,7 @@ async def test_copy_in_buffers_pg_error(aconn):
         async with cur.copy("copy copy_in from stdin (format text)") as copy:
             await copy.write(sample_text)
             await copy.write(sample_text)
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 async def test_copy_bad_result(aconn):
@@ -267,17 +265,17 @@ async def test_copy_in_error(aconn):
         async with cur.copy("copy copy_in from stdin (format binary)") as copy:
             await copy.write(sample_text.decode())
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_in_empty(aconn, format):
     cur = aconn.cursor()
     await ensure_table_async(cur, sample_tabledef)
     async with cur.copy(f"copy copy_in from stdin (format {format.name})"):
         pass
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.info.transaction_status == pq.TransactionStatus.INTRANS
     assert cur.rowcount == 0
 
 
@@ -307,9 +305,9 @@ async def test_copy_big_size_block(aconn, pytype):
     assert await cur.fetchone() == (data,)
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_subclass_adapter(aconn, format):
-    if format == Format.TEXT:
+    if format == pq.Format.TEXT:
         from psycopg.types.string import StrDumper as BaseDumper
     else:
         from psycopg.types.string import StrBinaryDumper
@@ -337,9 +335,9 @@ async def test_subclass_adapter(aconn, format):
     assert rec[0] == "hellohello"
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_subclass_nulling_dumper(aconn, format):
-    Base: type = StrNoneDumper if format == Format.TEXT else StrNoneBinaryDumper
+    Base: type = StrNoneDumper if format == pq.Format.TEXT else StrNoneBinaryDumper
 
     class MyStrDumper(Base):  # type: ignore
         def dump(self, obj):
@@ -361,7 +359,7 @@ async def test_subclass_nulling_dumper(aconn, format):
     assert recs == [("hello",), (None,)]
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_in_error_empty(aconn, format):
     cur = aconn.cursor()
     await ensure_table_async(cur, sample_tabledef)
@@ -369,7 +367,7 @@ async def test_copy_in_error_empty(aconn, format):
         async with cur.copy(f"copy copy_in from stdin (format {format.name})"):
             raise ZeroDivisionError("mannaggiamiseria")
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 async def test_copy_in_buffers_with_pg_error(aconn):
@@ -380,7 +378,7 @@ async def test_copy_in_buffers_with_pg_error(aconn):
             await copy.write(sample_text)
             await copy.write(sample_text)
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 async def test_copy_in_buffers_with_py_error(aconn):
@@ -391,7 +389,7 @@ async def test_copy_in_buffers_with_py_error(aconn):
             await copy.write(sample_text)
             raise ZeroDivisionError("nuttengoggenio")
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 async def test_copy_out_error_with_copy_finished(aconn):
@@ -401,7 +399,7 @@ async def test_copy_out_error_with_copy_finished(aconn):
             await copy.read_row()
             1 / 0
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
 async def test_copy_out_error_with_copy_not_finished(aconn):
@@ -413,7 +411,7 @@ async def test_copy_out_error_with_copy_not_finished(aconn):
             await copy.read_row()
             1 / 0
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 async def test_copy_out_server_error(aconn):
@@ -425,17 +423,17 @@ async def test_copy_out_server_error(aconn):
             async for block in copy:
                 pass
 
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_in_records(aconn, format):
     cur = aconn.cursor()
     await ensure_table_async(cur, sample_tabledef)
 
     async with cur.copy(f"copy copy_in from stdin (format {format.name})") as copy:
         for row in sample_records:
-            if format == Format.BINARY:
+            if format == pq.Format.BINARY:
                 row2 = tuple(Int4(i) if isinstance(i, int) else i for i in row)
                 row = row2  # type: ignore[assignment]
             await copy.write_row(row)
@@ -445,7 +443,7 @@ async def test_copy_in_records(aconn, format):
     assert data == sample_records
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_in_records_set_types(aconn, format):
     cur = aconn.cursor()
     await ensure_table_async(cur, sample_tabledef)
@@ -460,7 +458,7 @@ async def test_copy_in_records_set_types(aconn, format):
     assert data == sample_records
 
 
-@pytest.mark.parametrize("format", Format)
+@pytest.mark.parametrize("format", pq.Format)
 async def test_copy_in_records_binary(aconn, format):
     cur = aconn.cursor()
     await ensure_table_async(cur, "col1 serial primary key, col2 int, data text")
@@ -520,7 +518,8 @@ async def test_copy_in_format(aconn):
 
 
 @pytest.mark.parametrize(
-    "format, buffer", [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")]
+    "format, buffer",
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 async def test_file_writer(aconn, format, buffer):
     file = BytesIO()
@@ -663,7 +662,8 @@ async def test_description(aconn):
 
 
 @pytest.mark.parametrize(
-    "format, buffer", [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")]
+    "format, buffer",
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 async def test_worker_life(aconn, format, buffer):
     cur = aconn.cursor()
@@ -698,7 +698,8 @@ async def test_worker_error_propagated(aconn, monkeypatch):
 
 
 @pytest.mark.parametrize(
-    "format, buffer", [(Format.TEXT, "sample_text"), (Format.BINARY, "sample_binary")]
+    "format, buffer",
+    [(pq.Format.TEXT, "sample_text"), (pq.Format.BINARY, "sample_binary")],
 )
 async def test_connection_writer(aconn, format, buffer):
     cur = aconn.cursor()
@@ -719,7 +720,7 @@ async def test_connection_writer(aconn, format, buffer):
 @pytest.mark.slow
 @pytest.mark.parametrize(
     "fmt, set_types",
-    [(Format.TEXT, True), (Format.TEXT, False), (Format.BINARY, True)],
+    [(pq.Format.TEXT, True), (pq.Format.TEXT, False), (pq.Format.BINARY, True)],
 )
 @pytest.mark.parametrize("method", ["read", "iter", "row", "rows"])
 async def test_copy_to_leaks(aconn_cls, dsn, faker, fmt, set_types, method, gc):
@@ -775,7 +776,7 @@ async def test_copy_to_leaks(aconn_cls, dsn, faker, fmt, set_types, method, gc):
 @pytest.mark.slow
 @pytest.mark.parametrize(
     "fmt, set_types",
-    [(Format.TEXT, True), (Format.TEXT, False), (Format.BINARY, True)],
+    [(pq.Format.TEXT, True), (pq.Format.TEXT, False), (pq.Format.BINARY, True)],
 )
 async def test_copy_from_leaks(aconn_cls, dsn, faker, fmt, set_types, gc):
     faker.format = PyFormat.from_pq(fmt)

diff --git a/tests/test_cursor_common.py b/tests/test_cursor_common.py
index 7b3d9d5235599d67bb394d87470c419467812493..dbfdb3a6f881d806c48d2158f7cdd1f72ae7d084 100644 (file)
--- a/tests/test_cursor_common.py
+++ b/tests/test_cursor_common.py
@@ -13,7 +13,7 @@ from packaging.version import parse as ver
 import pytest
 
 import psycopg
-from psycopg import sql, rows
+from psycopg import pq, sql, rows
 from psycopg.adapt import PyFormat
 from psycopg.types import TypeInfo
 
@@ -229,7 +229,7 @@ def test_execute_sequence(conn):
 def test_execute_empty_query(conn, query):
     cur = conn.cursor()
     cur.execute(query)
-    assert cur.pgresult.status == cur.ExecStatus.EMPTY_QUERY
+    assert cur.pgresult.status == pq.ExecStatus.EMPTY_QUERY
     with pytest.raises(psycopg.ProgrammingError):
         cur.fetchone()
 
@@ -744,7 +744,7 @@ def test_stream_error_tx(conn):
     with pytest.raises(psycopg.ProgrammingError):
         for rec in cur.stream("wat"):
             pass
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 def test_stream_error_notx(conn):
@@ -753,7 +753,7 @@ def test_stream_error_notx(conn):
     with pytest.raises(psycopg.ProgrammingError):
         for rec in cur.stream("wat"):
             pass
-    assert conn.info.transaction_status == conn.TransactionStatus.IDLE
+    assert conn.info.transaction_status == pq.TransactionStatus.IDLE
 
 
 def test_stream_error_python_to_consume(conn):
@@ -763,8 +763,8 @@ def test_stream_error_python_to_consume(conn):
             for rec in gen:
                 1 / 0
     assert conn.info.transaction_status in (
-        conn.TransactionStatus.INTRANS,
-        conn.TransactionStatus.INERROR,
+        pq.TransactionStatus.INTRANS,
+        pq.TransactionStatus.INERROR,
     )
 
 
@@ -776,7 +776,7 @@ def test_stream_error_python_consumed(conn):
             1 / 0
 
     gen.close()
-    assert conn.info.transaction_status == conn.TransactionStatus.INTRANS
+    assert conn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
 @pytest.mark.parametrize("autocommit", [False, True])

diff --git a/tests/test_cursor_common_async.py b/tests/test_cursor_common_async.py
index 6421357e76a28a3d58701d3b85f6ecd18967cc8c..772a6db85f6180c551a0d75cf14f1b2cb206dcec 100644 (file)
--- a/tests/test_cursor_common_async.py
+++ b/tests/test_cursor_common_async.py
@@ -10,7 +10,7 @@ from packaging.version import parse as ver
 import pytest
 
 import psycopg
-from psycopg import sql, rows
+from psycopg import pq, sql, rows
 from psycopg.adapt import PyFormat
 from psycopg.types import TypeInfo
 
@@ -229,7 +229,7 @@ async def test_execute_sequence(aconn):
 async def test_execute_empty_query(aconn, query):
     cur = aconn.cursor()
     await cur.execute(query)
-    assert cur.pgresult.status == cur.ExecStatus.EMPTY_QUERY
+    assert cur.pgresult.status == pq.ExecStatus.EMPTY_QUERY
     with pytest.raises(psycopg.ProgrammingError):
         await cur.fetchone()
 
@@ -751,7 +751,7 @@ async def test_stream_error_tx(aconn):
     with pytest.raises(psycopg.ProgrammingError):
         async for rec in cur.stream("wat"):
             pass
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
 
 
 async def test_stream_error_notx(aconn):
@@ -760,7 +760,7 @@ async def test_stream_error_notx(aconn):
     with pytest.raises(psycopg.ProgrammingError):
         async for rec in cur.stream("wat"):
             pass
-    assert aconn.info.transaction_status == aconn.TransactionStatus.IDLE
+    assert aconn.info.transaction_status == pq.TransactionStatus.IDLE
 
 
 async def test_stream_error_python_to_consume(aconn):
@@ -770,8 +770,8 @@ async def test_stream_error_python_to_consume(aconn):
             async for rec in gen:
                 1 / 0
     assert aconn.info.transaction_status in (
-        aconn.TransactionStatus.INTRANS,
-        aconn.TransactionStatus.INERROR,
+        pq.TransactionStatus.INTRANS,
+        pq.TransactionStatus.INERROR,
     )
 
 
@@ -783,7 +783,7 @@ async def test_stream_error_python_consumed(aconn):
             1 / 0
 
     await gen.aclose()
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INTRANS
+    assert aconn.info.transaction_status == pq.TransactionStatus.INTRANS
 
 
 @pytest.mark.parametrize("autocommit", [False, True])

diff --git a/tests/test_cursor_server.py b/tests/test_cursor_server.py
index b4259abb2f3bc127f9283e088817092514194189..e237d261e1ddf14ff25a4def51f804c5a822b812 100644 (file)
--- a/tests/test_cursor_server.py
+++ b/tests/test_cursor_server.py
@@ -4,8 +4,7 @@
 import pytest
 
 import psycopg
-from psycopg import rows, errors as e
-from psycopg.pq import Format
+from psycopg import pq, rows, errors as e
 
 
 pytestmark = pytest.mark.crdb_skip("server-side cursor")
@@ -73,11 +72,11 @@ def test_description(conn):
 
 def test_format(conn):
     cur = conn.cursor("foo")
-    assert cur.format == Format.TEXT
+    assert cur.format == pq.Format.TEXT
     cur.close()
 
     cur = conn.cursor("foo", binary=True)
-    assert cur.format == Format.BINARY
+    assert cur.format == pq.Format.BINARY
     cur.close()
 
 
@@ -138,7 +137,7 @@ def test_binary_cursor_text_override(conn):
 
 
 def test_close(conn, recwarn):
-    if conn.info.transaction_status == conn.TransactionStatus.INTRANS:
+    if conn.info.transaction_status == pq.TransactionStatus.INTRANS:
         # connection dirty from previous failure
         conn.execute("close foo")
     recwarn.clear()
@@ -225,7 +224,7 @@ def test_close_on_error(conn):
     cur.execute("select 1")
     with pytest.raises(e.ProgrammingError):
         conn.execute("wat")
-    assert conn.info.transaction_status == conn.TransactionStatus.INERROR
+    assert conn.info.transaction_status == pq.TransactionStatus.INERROR
     cur.close()
 
 

diff --git a/tests/test_cursor_server_async.py b/tests/test_cursor_server_async.py
index 0f0efa2a96c69797e83bd6c97d69f3e5e192c763..16cb3f2daf08fcc6d36457225ecfae96db3a3c82 100644 (file)
--- a/tests/test_cursor_server_async.py
+++ b/tests/test_cursor_server_async.py
@@ -1,8 +1,7 @@
 import pytest
 
 import psycopg
-from psycopg import rows, errors as e
-from psycopg.pq import Format
+from psycopg import pq, rows, errors as e
 
 from .acompat import alist
 
@@ -76,11 +75,11 @@ async def test_description(aconn):
 
 async def test_format(aconn):
     cur = aconn.cursor("foo")
-    assert cur.format == Format.TEXT
+    assert cur.format == pq.Format.TEXT
     await cur.close()
 
     cur = aconn.cursor("foo", binary=True)
-    assert cur.format == Format.BINARY
+    assert cur.format == pq.Format.BINARY
     await cur.close()
 
 
@@ -141,7 +140,7 @@ async def test_binary_cursor_text_override(aconn):
 
 
 async def test_close(aconn, recwarn):
-    if aconn.info.transaction_status == aconn.TransactionStatus.INTRANS:
+    if aconn.info.transaction_status == pq.TransactionStatus.INTRANS:
         # connection dirty from previous failure
         await aconn.execute("close foo")
     recwarn.clear()
@@ -230,7 +229,7 @@ async def test_close_on_error(aconn):
     await cur.execute("select 1")
     with pytest.raises(e.ProgrammingError):
         await aconn.execute("wat")
-    assert aconn.info.transaction_status == aconn.TransactionStatus.INERROR
+    assert aconn.info.transaction_status == pq.TransactionStatus.INERROR
     await cur.close()
 
 

diff --git a/tests/test_transaction.py b/tests/test_transaction.py
index a82a8f9c7fce0ae8fa3d65fb3be4486a3e1b9bf8..1f18f40dc8def8e088f3805b7efbc95904720db7 100644 (file)
--- a/tests/test_transaction.py
+++ b/tests/test_transaction.py
@@ -6,7 +6,7 @@ import logging
 import pytest
 
 from psycopg import Rollback
-from psycopg import errors as e
+from psycopg import pq, errors as e
 
 from ._test_transaction import in_transaction, insert_row, inserted, get_exc_info
 from ._test_transaction import ExpectedException, crdb_skip_external_observer
@@ -117,7 +117,7 @@ def test_context_active_rollback_no_clobber(conn_cls, dsn, caplog):
             with conn.transaction():
                 conn.pgconn.exec_(b"copy (select generate_series(1, 10)) to stdout")
                 status = conn.info.transaction_status
-                assert status == conn.TransactionStatus.ACTIVE
+                assert status == pq.TransactionStatus.ACTIVE
                 1 / 0
 
         assert len(caplog.records) == 1

diff --git a/tests/test_transaction_async.py b/tests/test_transaction_async.py
index 1268201255fc8c5e2d9ad86e368606ba7e0b29f5..c78dcb1f6aa3f9df03f9fd7da6e2956400c97ba5 100644 (file)
--- a/tests/test_transaction_async.py
+++ b/tests/test_transaction_async.py
@@ -3,7 +3,7 @@ import logging
 import pytest
 
 from psycopg import Rollback
-from psycopg import errors as e
+from psycopg import pq, errors as e
 
 from ._test_transaction import in_transaction, insert_row, inserted, get_exc_info
 from ._test_transaction import ExpectedException, crdb_skip_external_observer
@@ -117,7 +117,7 @@ async def test_context_active_rollback_no_clobber(aconn_cls, dsn, caplog):
             async with conn.transaction():
                 conn.pgconn.exec_(b"copy (select generate_series(1, 10)) to stdout")
                 status = conn.info.transaction_status
-                assert status == conn.TransactionStatus.ACTIVE
+                assert status == pq.TransactionStatus.ACTIVE
                 1 / 0
 
         assert len(caplog.records) == 1