b = dumper.dump(item)
out += _dump_re.sub(_dump_sub, b)
else:
- out += br"\N"
+ out += rb"\N"
out += b"\t"
out[-1:] = b"\n"
# Double quotes and backslashes embedded in element values will be
# backslash-escaped.
- _re_esc = re.compile(br'(["\\])')
+ _re_esc = re.compile(rb'(["\\])')
def dump(self, obj: List[Any]) -> bytes:
tokens: List[bytes] = []
if needs_quotes(ad):
if not isinstance(ad, bytes):
ad = bytes(ad)
- ad = b'"' + self._re_esc.sub(br"\\\1", ad) + b'"'
+ ad = b'"' + self._re_esc.sub(rb"\\\1", ad) + b'"'
tokens.append(ad)
else:
tokens.append(b"NULL")
double quotes, backslashes, or white space, or match the word NULL.
"""
return re.compile(
- br"""(?xi)
+ rb"""(?xi)
^$ # the empty string
| ["{}%s\\\s] # or a char to escape
| ^null$ # or the word NULL
v = None
else:
if t.startswith(b'"'):
- t = self._re_unescape.sub(br"\1", t[1:-1])
+ t = self._re_unescape.sub(rb"\1", t[1:-1])
v = cast(t)
stack[-1].append(v)
assert rv is not None
return rv
- _re_unescape = re.compile(br"\\(.)")
+ _re_unescape = re.compile(rb"\\(.)")
@lru_cache()
Return a regexp to tokenize an array representation into item and brackets
"""
return re.compile(
- br"""(?xi)
+ rb"""(?xi)
( [{}] # open or closed bracket
| " (?: [^"\\] | \\. )* " # or a quoted string
| [^"{}%s\\]+ # or an unquoted non-empty string
if not ad:
ad = b'""'
elif self._re_needs_quotes.search(ad):
- ad = b'"' + self._re_esc.sub(br"\1\1", ad) + b'"'
+ ad = b'"' + self._re_esc.sub(rb"\1\1", ad) + b'"'
parts.append(ad)
parts.append(sep)
return b"".join(parts)
- _re_needs_quotes = re.compile(br'[",\\\s()]')
- _re_esc = re.compile(br"([\\\"])")
+ _re_needs_quotes = re.compile(rb'[",\\\s()]')
+ _re_esc = re.compile(rb"([\\\"])")
class TupleDumper(SequenceDumper):
if m.group(1):
yield None
elif m.group(2) is not None:
- yield self._re_undouble.sub(br"\1", m.group(2))
+ yield self._re_undouble.sub(rb"\1", m.group(2))
else:
yield m.group(3)
yield None
_re_tokenize = re.compile(
- br"""(?x)
+ rb"""(?x)
(,) # an empty token, representing NULL
| " ((?: [^"] | "")*) " ,? # or a quoted string
| ([^",)]+) ,? # or an unquoted string
"""
)
- _re_undouble = re.compile(br'(["\\])\1')
+ _re_undouble = re.compile(rb'(["\\])\1')
class RecordLoader(BaseCompositeLoader):
class IntervalLoader(Loader):
_re_interval = re.compile(
- br"""
+ rb"""
(?: ([-+]?\d+) \s+ years? \s* )? # Years
(?: ([-+]?\d+) \s+ mons? \s* )? # Months
(?: ([-+]?\d+) \s+ days? \s* )? # Days
_int_numeric_dumper = IntNumericDumper(IntNumeric)
def upgrade(self, obj: int, format: PyFormat) -> Dumper:
- if -(2 ** 31) <= obj < 2 ** 31:
- if -(2 ** 15) <= obj < 2 ** 15:
+ if -(2**31) <= obj < 2**31:
+ if -(2**15) <= obj < 2**15:
return self._int2_dumper
else:
return self._int4_dumper
else:
- if -(2 ** 63) <= obj < 2 ** 63:
+ if -(2**63) <= obj < 2**63:
return self._int8_dumper
else:
return self._int_numeric_dumper
if not ad:
return b'""'
elif _re_needs_quotes.search(ad):
- return b'"' + _re_esc.sub(br"\1\1", ad) + b'"'
+ return b'"' + _re_esc.sub(rb"\1\1", ad) + b'"'
else:
return ad
return b"".join(parts)
-_re_needs_quotes = re.compile(br'[",\\\s()\[\]]')
-_re_esc = re.compile(br"([\\\"])")
+_re_needs_quotes = re.compile(rb'[",\\\s()\[\]]')
+_re_esc = re.compile(rb"([\\\"])")
class RangeBinaryDumper(BaseRangeDumper):
],
# Requirements needed for development
"dev": [
- "black >= 21.12b0",
+ "black >= 22.1.0",
"dnspython >= 2.1",
"flake8 >= 4.0",
"mypy >= 0.920, != 0.930, != 0.931",
pytest-randomly == 3.10.0
# From the 'dev' extra
-black == 21.12b0
+black == 22.1.0
dnspython == 2.1.0
flake8 == 4.0.0
mypy == 0.920
@pytest.mark.parametrize("data", [(b"hello\00world"), (b"\00\00\00\00")])
def test_escape_bytea(pgconn, data):
- exp = br"\x" + b"".join(b"%02x" % c for c in data)
+ exp = rb"\x" + b"".join(b"%02x" % c for c in data)
esc = pq.Escaping(pgconn)
rv = esc.escape_bytea(data)
assert rv == exp
esc = pq.Escaping(pgconn)
for c in range(256):
rv = esc.escape_bytea(bytes([c]))
- exp = br"\x%02x" % c
+ exp = rb"\x%02x" % c
assert rv == exp
@pytest.mark.parametrize("data", [(b"hello\00world"), (b"\00\00\00\00")])
def test_unescape_bytea(pgconn, data):
- enc = br"\x" + b"".join(b"%02x" % c for c in data)
+ enc = rb"\x" + b"".join(b"%02x" % c for c in data)
esc = pq.Escaping(pgconn)
rv = esc.unescape_bytea(enc)
assert rv == data
(-1, "'-1'::int"),
(42, "'42'::smallint"),
(-42, "'-42'::smallint"),
- (int(2 ** 63 - 1), "'9223372036854775807'::bigint"),
- (int(-(2 ** 63)), "'-9223372036854775808'::bigint"),
+ (int(2**63 - 1), "'9223372036854775807'::bigint"),
+ (int(-(2**63)), "'-9223372036854775808'::bigint"),
],
)
@pytest.mark.parametrize("fmt_in", PyFormat)
(-1, "'-1'::smallint"),
(42, "'42'::smallint"),
(-42, "'-42'::smallint"),
- (int(2 ** 15 - 1), f"'{2 ** 15 - 1}'::smallint"),
- (int(-(2 ** 15)), f"'{-2 ** 15}'::smallint"),
- (int(2 ** 15), f"'{2 ** 15}'::integer"),
- (int(-(2 ** 15) - 1), f"'{-2 ** 15 - 1}'::integer"),
- (int(2 ** 31 - 1), f"'{2 ** 31 - 1}'::integer"),
- (int(-(2 ** 31)), f"'{-2 ** 31}'::integer"),
- (int(2 ** 31), f"'{2 ** 31}'::bigint"),
- (int(-(2 ** 31) - 1), f"'{-2 ** 31 - 1}'::bigint"),
- (int(2 ** 63 - 1), f"'{2 ** 63 - 1}'::bigint"),
- (int(-(2 ** 63)), f"'{-2 ** 63}'::bigint"),
- (int(2 ** 63), f"'{2 ** 63}'::numeric"),
- (int(-(2 ** 63) - 1), f"'{-2 ** 63 - 1}'::numeric"),
+ (int(2**15 - 1), f"'{2 ** 15 - 1}'::smallint"),
+ (int(-(2**15)), f"'{-2 ** 15}'::smallint"),
+ (int(2**15), f"'{2 ** 15}'::integer"),
+ (int(-(2**15) - 1), f"'{-2 ** 15 - 1}'::integer"),
+ (int(2**31 - 1), f"'{2 ** 31 - 1}'::integer"),
+ (int(-(2**31)), f"'{-2 ** 31}'::integer"),
+ (int(2**31), f"'{2 ** 31}'::bigint"),
+ (int(-(2**31) - 1), f"'{-2 ** 31 - 1}'::bigint"),
+ (int(2**63 - 1), f"'{2 ** 63 - 1}'::bigint"),
+ (int(-(2**63)), f"'{-2 ** 63}'::bigint"),
+ (int(2**63), f"'{2 ** 63}'::numeric"),
+ (int(-(2**63) - 1), f"'{-2 ** 63 - 1}'::numeric"),
],
)
@pytest.mark.parametrize("fmt_in", PyFormat)
(-1, b" -1"),
(42, b"42"),
(-42, b" -42"),
- (int(2 ** 63 - 1), b"9223372036854775807"),
- (int(-(2 ** 63)), b" -9223372036854775808"),
- (int(2 ** 63), b"9223372036854775808"),
- (int(-(2 ** 63 + 1)), b" -9223372036854775809"),
- (int(2 ** 100), b"1267650600228229401496703205376"),
- (int(-(2 ** 100)), b" -1267650600228229401496703205376"),
+ (int(2**63 - 1), b"9223372036854775807"),
+ (int(-(2**63)), b" -9223372036854775808"),
+ (int(2**63), b"9223372036854775808"),
+ (int(-(2**63 + 1)), b" -9223372036854775809"),
+ (int(2**100), b"1267650600228229401496703205376"),
+ (int(-(2**100)), b" -1267650600228229401496703205376"),
],
)
def test_quote_int(conn, val, expr):
samples = [
("int4range", None, None, "()"),
("int4range", 10, 20, "[]"),
- ("int4range", -(2 ** 31), (2 ** 31) - 1, "[)"),
+ ("int4range", -(2**31), (2**31) - 1, "[)"),
("int8range", None, None, "()"),
("int8range", 10, 20, "[)"),
- ("int8range", -(2 ** 63), (2 ** 63) - 1, "[)"),
+ ("int8range", -(2**63), (2**63) - 1, "[)"),
("numrange", Decimal(-100), Decimal("100.123"), "(]"),
("numrange", Decimal(100), None, "()"),
("numrange", None, Decimal(100), "()"),
istart, iend = [
i
for i, line in enumerate(lines)
- if re.match(br"\s*#\s*autogenerated:\s+(start|end)", line)
+ if re.match(rb"\s*#\s*autogenerated:\s+(start|end)", line)
]
lines[istart + 1 : iend] = new