binary attribute replaced by format

diff --git a/psycopg3/connection.py b/psycopg3/connection.py
index 90992c32d64559a4e27993068ad5e5c3d0f79093..ad53864761c54adc89be5441d261554bc4d9901e 100644 (file)
--- a/psycopg3/connection.py
+++ b/psycopg3/connection.py
@@ -114,11 +114,11 @@ class BaseConnection:
         self._autocommit = value
 
     def cursor(
-        self, name: Optional[str] = None, binary: bool = False
+        self, name: Optional[str] = None, format: pq.Format = pq.Format.TEXT
     ) -> cursor.BaseCursor:
         if name is not None:
             raise NotImplementedError
-        return self.cursor_factory(self, binary=binary)
+        return self.cursor_factory(self, format=format)
 
     @property
     def codec(self) -> codecs.CodecInfo:
@@ -231,9 +231,9 @@ class Connection(BaseConnection):
         self.pgconn.finish()
 
     def cursor(
-        self, name: Optional[str] = None, binary: bool = False
+        self, name: Optional[str] = None, format: pq.Format = pq.Format.TEXT
     ) -> cursor.Cursor:
-        cur = super().cursor(name, binary)
+        cur = super().cursor(name, format=format)
         return cast(cursor.Cursor, cur)
 
     def _start_query(self) -> None:
@@ -338,9 +338,9 @@ class AsyncConnection(BaseConnection):
         self.pgconn.finish()
 
     def cursor(
-        self, name: Optional[str] = None, binary: bool = False
+        self, name: Optional[str] = None, format: pq.Format = pq.Format.TEXT
     ) -> cursor.AsyncCursor:
-        cur = super().cursor(name, binary)
+        cur = super().cursor(name, format=format)
         return cast(cursor.AsyncCursor, cur)
 
     async def _start_query(self) -> None:

diff --git a/psycopg3/cursor.py b/psycopg3/cursor.py
index 3a81e5f62214adac8855943f2160043e1e894400..eb59831e0057387f9ee03fe7c2592bfa0317aba2 100644 (file)
--- a/psycopg3/cursor.py
+++ b/psycopg3/cursor.py
@@ -70,9 +70,11 @@ class BaseCursor:
 
     _transformer: proto.Transformer
 
-    def __init__(self, connection: "BaseConnection", binary: bool = False):
+    def __init__(
+        self, connection: "BaseConnection", format: pq.Format = pq.Format.TEXT
+    ):
         self.connection = connection
-        self.binary = binary
+        self.format = format
         self.dumpers: DumpersMap = {}
         self.loaders: LoadersMap = {}
         self._reset()
@@ -165,15 +167,15 @@ class BaseCursor:
                 pgq.params,
                 param_formats=pgq.formats,
                 param_types=pgq.types,
-                result_format=pq.Format(self.binary),
+                result_format=self.format,
             )
 
         else:
             # if we don't have to, let's use exec_ as it can run more than
             # one query in one go
-            if self.binary:
+            if self.format == pq.Format.BINARY:
                 self.connection.pgconn.send_query_params(
-                    pgq.query, None, result_format=pq.Format(self.binary)
+                    pgq.query, None, result_format=self.format
                 )
             else:
                 self.connection.pgconn.send_query(pgq.query)
@@ -228,7 +230,7 @@ class BaseCursor:
             name,
             pgq.params,
             param_formats=pgq.formats,
-            result_format=pq.Format(self.binary),
+            result_format=self.format,
         )
 
     def nextset(self) -> Optional[bool]:
@@ -253,8 +255,10 @@ class BaseCursor:
 class Cursor(BaseCursor):
     connection: "Connection"
 
-    def __init__(self, connection: "Connection", binary: bool = False):
-        super().__init__(connection, binary)
+    def __init__(
+        self, connection: "Connection", format: pq.Format = pq.Format.TEXT
+    ):
+        super().__init__(connection, format=format)
 
     def close(self) -> None:
         self._closed = True
@@ -343,8 +347,10 @@ class Cursor(BaseCursor):
 class AsyncCursor(BaseCursor):
     connection: "AsyncConnection"
 
-    def __init__(self, connection: "AsyncConnection", binary: bool = False):
-        super().__init__(connection, binary)
+    def __init__(
+        self, connection: "AsyncConnection", format: pq.Format = pq.Format.TEXT
+    ):
+        super().__init__(connection, format=format)
 
     async def close(self) -> None:
         self._closed = True

diff --git a/psycopg3/types/composite.py b/psycopg3/types/composite.py
index 610912520e1e39891006c48eb36eaa922b3807b6..3b29c34622788e3bf804a0378ba8d09b20e1ff52 100644 (file)
--- a/psycopg3/types/composite.py
+++ b/psycopg3/types/composite.py
@@ -8,9 +8,10 @@ from collections import namedtuple
 from typing import Any, Callable, Generator, Sequence, Tuple
 from typing import Optional, TYPE_CHECKING
 
-from . import array
+from .. import pq
 from ..adapt import Format, Dumper, Loader, Transformer
 from ..proto import AdaptContext
+from . import array
 from .oids import builtins, TypeInfo
 
 if TYPE_CHECKING:
@@ -44,7 +45,7 @@ class CompositeTypeInfo(TypeInfo):
 
 
 def fetch_info(conn: "Connection", name: str) -> Optional[CompositeTypeInfo]:
-    cur = conn.cursor(binary=True)
+    cur = conn.cursor(format=pq.Format.BINARY)
     cur.execute(_type_info_query, {"name": name})
     rec = cur.fetchone()
     return CompositeTypeInfo._from_record(rec)
@@ -53,7 +54,7 @@ def fetch_info(conn: "Connection", name: str) -> Optional[CompositeTypeInfo]:
 async def fetch_info_async(
     conn: "AsyncConnection", name: str
 ) -> Optional[CompositeTypeInfo]:
-    cur = conn.cursor(binary=True)
+    cur = conn.cursor(format=pq.Format.BINARY)
     await cur.execute(_type_info_query, {"name": name})
     rec = await cur.fetchone()
     return CompositeTypeInfo._from_record(rec)

diff --git a/tests/test_adapt.py b/tests/test_adapt.py
index 3eaec8ddbffada6311e37fef1d877af597e66cba..a22c4e1ea991179bb108260f6334b81c33a66b78 100644 (file)
--- a/tests/test_adapt.py
+++ b/tests/test_adapt.py
@@ -72,7 +72,7 @@ def test_load_connection_ctx(conn):
 
     r = conn.cursor().execute("select 'hello'::text").fetchone()
     assert r == ("hellot",)
-    r = conn.cursor(binary=True).execute("select 'hello'::text").fetchone()
+    r = conn.cursor(format=1).execute("select 'hello'::text").fetchone()
     assert r == ("hellob",)
 
 
@@ -86,14 +86,14 @@ def test_load_cursor_ctx(conn):
 
     r = cur.execute("select 'hello'::text").fetchone()
     assert r == ("hellotc",)
-    cur.binary = True
+    cur.format = Format.BINARY
     r = cur.execute("select 'hello'::text").fetchone()
     assert r == ("hellobc",)
 
     cur = conn.cursor()
     r = cur.execute("select 'hello'::text").fetchone()
     assert r == ("hellot",)
-    cur.binary = True
+    cur.format = Format.BINARY
     r = cur.execute("select 'hello'::text").fetchone()
     assert r == ("hellob",)
 
@@ -104,7 +104,7 @@ def test_load_cursor_ctx(conn):
 )
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_load_cursor_ctx_nested(conn, sql, obj, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     Loader.register(
         TEXT_OID, lambda b: b.decode("ascii") + "c", cur, format=fmt_out
     )

diff --git a/tests/test_cursor.py b/tests/test_cursor.py
index d59417aa01ba9d6cc4f7ed4663b87b9af189ec01..f1ada858845cc91e44ac5e3e6a2b7c50e8be7347 100644 (file)
--- a/tests/test_cursor.py
+++ b/tests/test_cursor.py
@@ -88,7 +88,7 @@ def test_fetchone(conn):
 
 
 def test_execute_binary_result(conn):
-    cur = conn.cursor(binary=True)
+    cur = conn.cursor(format=psycopg3.pq.Format.BINARY)
     cur.execute("select %s, %s", ["foo", None])
     assert cur.pgresult.fformat(0) == 1
 

diff --git a/tests/test_cursor_async.py b/tests/test_cursor_async.py
index 0c19d70d43c80d570bf18dbda486984af6408b57..e0f51438b968d80de9a4c6948a55c705b27eba4b 100644 (file)
--- a/tests/test_cursor_async.py
+++ b/tests/test_cursor_async.py
@@ -90,7 +90,7 @@ async def test_fetchone(aconn):
 
 
 async def test_execute_binary_result(aconn):
-    cur = aconn.cursor(binary=True)
+    cur = aconn.cursor(format=psycopg3.pq.Format.BINARY)
     await cur.execute("select %s, %s", ["foo", None])
     assert cur.pgresult.fformat(0) == 1
 

diff --git a/tests/types/test_array.py b/tests/types/test_array.py
index 28b9c085f5b17c8fbd1cbb5b6b4298237bc2b5f9..0ad2884244ea9b7288b39d54a006e90e06e66a73 100644 (file)
--- a/tests/types/test_array.py
+++ b/tests/types/test_array.py
@@ -34,7 +34,7 @@ def test_dump_list_str(conn, obj, want, fmt_in):
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 @pytest.mark.parametrize("want, obj", tests_str)
 def test_load_list_str(conn, obj, want, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     cur.execute("select %s::text[]", (obj,))
     assert cur.fetchone()[0] == want
 
@@ -42,7 +42,7 @@ def test_load_list_str(conn, obj, want, fmt_out):
 @pytest.mark.parametrize("fmt_in", [Format.TEXT, Format.BINARY])
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_all_chars(conn, fmt_in, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     ph = "%s" if fmt_in == Format.TEXT else "%b"
     for i in range(1, 256):
         c = chr(i)
@@ -94,7 +94,7 @@ def test_bad_binary_array(input):
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 @pytest.mark.parametrize("want, obj", tests_int)
 def test_load_list_int(conn, obj, want, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     cur.execute("select %s::int[]", (obj,))
     assert cur.fetchone()[0] == want
 

diff --git a/tests/types/test_composite.py b/tests/types/test_composite.py
index aa25f83b9d98a9e7f9f302d1b1c537f4bc1b392b..71accd0ec0eadb21d2910a29ce20ee620cf40dd9 100644 (file)
--- a/tests/types/test_composite.py
+++ b/tests/types/test_composite.py
@@ -44,7 +44,7 @@ def test_dump_tuple(conn, rec, obj):
 
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_load_all_chars(conn, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     for i in range(1, 256):
         res = cur.execute("select row(chr(%s::int))", (i,)).fetchone()[0]
         assert res == (chr(i),)
@@ -83,7 +83,7 @@ def test_load_all_chars(conn, fmt_out):
     ],
 )
 def test_load_record_binary(conn, want, rec):
-    cur = conn.cursor(binary=True)
+    cur = conn.cursor(format=1)
     res = cur.execute(f"select row({rec})").fetchone()[0]
     assert res == want
     for o1, o2 in zip(res, want):
@@ -131,7 +131,7 @@ async def test_fetch_info_async(aconn, testcomp):
 
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_load_composite(conn, testcomp, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     info = composite.fetch_info(conn, "testcomp")
     composite.register(info, conn)
 
@@ -151,7 +151,7 @@ def test_load_composite(conn, testcomp, fmt_out):
 
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_load_composite_factory(conn, testcomp, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     info = composite.fetch_info(conn, "testcomp")
 
     class MyThing:

diff --git a/tests/types/test_numeric.py b/tests/types/test_numeric.py
index ecd078d62f97af8dbb85ad1f08dec19057ad0674..22c4fc8126251233836f3ad42d759938312fe511 100644 (file)
--- a/tests/types/test_numeric.py
+++ b/tests/types/test_numeric.py
@@ -62,7 +62,7 @@ def test_dump_int_binary():
 )
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_load_int(conn, val, pgtype, want, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     cur.execute(f"select %s::{pgtype}", (val,))
     assert cur.pgresult.fformat(0) == fmt_out
     assert cur.pgresult.ftype(0) == builtins[pgtype].oid
@@ -156,7 +156,7 @@ def test_dump_float_binary():
 )
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_load_float(conn, val, pgtype, want, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     cur.execute(f"select %s::{pgtype}", (val,))
     assert cur.pgresult.fformat(0) == fmt_out
     assert cur.pgresult.ftype(0) == builtins[pgtype].oid
@@ -197,7 +197,7 @@ def test_load_float(conn, val, pgtype, want, fmt_out):
 )
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_load_float_approx(conn, expr, pgtype, want, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     cur.execute("select %s::%s" % (expr, pgtype))
     assert cur.pgresult.fformat(0) == fmt_out
     result = cur.fetchone()[0]
@@ -241,7 +241,7 @@ def test_dump_numeric_binary():
 @pytest.mark.xfail
 def test_load_numeric_binary(conn):
     # TODO: numeric binary casting
-    cur = conn.cursor(binary=True)
+    cur = conn.cursor(format=1)
     res = cur.execute("select 1::numeric").fetchone()[0]
     assert res == Decimal(1)
 
@@ -289,7 +289,7 @@ def test_numeric_as_float(conn, val):
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 @pytest.mark.parametrize("b", [True, False, None])
 def test_roundtrip_bool(conn, b, fmt_in, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     ph = "%s" if fmt_in == Format.TEXT else "%b"
     result = cur.execute(f"select {ph}", (b,)).fetchone()[0]
     assert cur.pgresult.fformat(0) == fmt_out

diff --git a/tests/types/test_text.py b/tests/types/test_text.py
index 977fa8111669035a4654640009ae2665bc7a146f..28c09ab6e47416312e44d195d870f3f687bd5332 100644 (file)
--- a/tests/types/test_text.py
+++ b/tests/types/test_text.py
@@ -23,7 +23,7 @@ def test_dump_1char(conn, fmt_in):
 @pytest.mark.parametrize("typename", ["text", "varchar", "name", "bpchar"])
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_load_1char(conn, typename, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     for i in range(1, 256):
         cur.execute(f"select chr(%s::int)::{typename}", (i,))
         res = cur.fetchone()[0]
@@ -67,7 +67,7 @@ def test_dump_badenc(conn, fmt_in):
 @pytest.mark.parametrize("encoding", ["utf8", "latin9"])
 @pytest.mark.parametrize("typename", ["text", "varchar", "name", "bpchar"])
 def test_load_enc(conn, typename, encoding, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
 
     conn.set_client_encoding(encoding)
     (res,) = cur.execute(
@@ -79,7 +79,7 @@ def test_load_enc(conn, typename, encoding, fmt_out):
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 @pytest.mark.parametrize("typename", ["text", "varchar", "name", "bpchar"])
 def test_load_badenc(conn, typename, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
 
     conn.set_client_encoding("latin1")
     with pytest.raises(psycopg3.DatabaseError):
@@ -89,7 +89,7 @@ def test_load_badenc(conn, typename, fmt_out):
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 @pytest.mark.parametrize("typename", ["text", "varchar"])
 def test_load_ascii(conn, typename, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
 
     conn.set_client_encoding("sql_ascii")
     (res,) = cur.execute(
@@ -101,7 +101,7 @@ def test_load_ascii(conn, typename, fmt_out):
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 @pytest.mark.parametrize("typename", ["name", "bpchar"])
 def test_load_ascii_encanyway(conn, typename, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
 
     conn.set_client_encoding("sql_ascii")
     (res,) = cur.execute(f"select 'aa'::{typename}").fetchone()
@@ -112,7 +112,7 @@ def test_load_ascii_encanyway(conn, typename, fmt_out):
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 @pytest.mark.parametrize("typename", ["text", "varchar", "name", "bpchar"])
 def test_text_array(conn, typename, fmt_in, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     ph = "%s" if fmt_in == Format.TEXT else "%b"
     a = list(map(chr, range(1, 256))) + [eur]
 
@@ -124,7 +124,7 @@ def test_text_array(conn, typename, fmt_in, fmt_out):
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_text_array_ascii(conn, fmt_in, fmt_out):
     conn.set_client_encoding("sql_ascii")
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     a = list(map(chr, range(1, 256))) + [eur]
     exp = [s.encode("utf8") for s in a]
     ph = "%s" if fmt_in == Format.TEXT else "%b"
@@ -148,7 +148,7 @@ def test_dump_1byte(conn, fmt_in):
 
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_load_1byte(conn, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     for i in range(0, 256):
         cur.execute("select %s::bytea", (fr"\x{i:02x}",))
         assert cur.fetchone()[0] == bytes([i])
@@ -159,7 +159,7 @@ def test_load_1byte(conn, fmt_out):
 @pytest.mark.parametrize("fmt_in", [Format.TEXT, Format.BINARY])
 @pytest.mark.parametrize("fmt_out", [Format.TEXT, Format.BINARY])
 def test_bytea_array(conn, fmt_in, fmt_out):
-    cur = conn.cursor(binary=fmt_out == Format.BINARY)
+    cur = conn.cursor(format=fmt_out)
     a = [bytes(range(0, 256))]
     ph = "%s" if fmt_in == Format.TEXT else "%b"
     (res,) = cur.execute(f"select {ph}::bytea[]", (a,)).fetchone()