from .cursor import BaseCursor
from .types.oids import type_oid, INVALID_OID
from .connection import BaseConnection
-from .utils.typing import DecodeFunc
+from .utils.typing import DecodeFunc, Oid
# Type system
AdaptContext = Union[BaseConnection, BaseCursor]
-MaybeOid = Union[Optional[bytes], Tuple[Optional[bytes], int]]
+MaybeOid = Union[Optional[bytes], Tuple[Optional[bytes], Oid]]
AdapterFunc = Callable[[Any], MaybeOid]
AdapterType = Union["Adapter", AdapterFunc]
AdaptersMap = Dict[Tuple[type, Format], AdapterType]
TypecasterFunc = Callable[[bytes], Any]
TypecasterType = Union["Typecaster", TypecasterFunc]
-TypecastersMap = Dict[Tuple[int, Format], TypecasterType]
+TypecastersMap = Dict[Tuple[Oid, Format], TypecasterType]
class Adapter:
self.cls = cls
self.conn = conn
- def adapt(self, obj: Any) -> Union[bytes, Tuple[bytes, int]]:
+ def adapt(self, obj: Any) -> Union[bytes, Tuple[bytes, Oid]]:
raise NotImplementedError()
@staticmethod
class Typecaster:
globals: TypecastersMap = {}
- def __init__(self, oid: int, conn: Optional[BaseConnection]):
+ def __init__(self, oid: Oid, conn: Optional[BaseConnection]):
self.oid = oid
self.conn = conn
@staticmethod
def register(
- oid: int,
+ oid: Oid,
caster: TypecasterType,
context: Optional[AdaptContext] = None,
format: Format = Format.TEXT,
@staticmethod
def register_binary(
- oid: int,
+ oid: Oid,
caster: TypecasterType,
context: Optional[AdaptContext] = None,
) -> TypecasterType:
return Typecaster.register(oid, caster, context, format=Format.BINARY)
@staticmethod
- def text(oid: int) -> Callable[[Any], Any]:
+ def text(oid: Oid) -> Callable[[Any], Any]:
def register_caster_(caster: TypecasterType) -> TypecasterType:
Typecaster.register(oid, caster)
return caster
return register_caster_
@staticmethod
- def binary(oid: int) -> Callable[[Any], Any]:
+ def binary(oid: Oid) -> Callable[[Any], Any]:
def register_binary_caster_(caster: TypecasterType) -> TypecasterType:
Typecaster.register_binary(oid, caster)
return caster
def adapt_sequence(
self, objs: Sequence[Any], fmts: Sequence[Format]
- ) -> Tuple[List[Optional[bytes]], List[int]]:
+ ) -> Tuple[List[Optional[bytes]], List[Oid]]:
out = []
types = []
v = func(v)
yield v
- def get_cast_function(self, oid: int, fmt: Format) -> TypecasterFunc:
+ def get_cast_function(self, oid: Oid, fmt: Format) -> TypecasterFunc:
try:
return self._cast_funcs[oid, fmt]
except KeyError:
else:
return cast(TypecasterFunc, caster)
- def lookup_caster(self, oid: int, fmt: Format) -> TypecasterType:
+ def lookup_caster(self, oid: Oid, fmt: Format) -> TypecasterType:
key = (oid, fmt)
cur = self.cursor
Fallback object to convert unknown types to Python
"""
- def __init__(self, oid: int, conn: Optional[BaseConnection]):
+ def __init__(self, oid: Oid, conn: Optional[BaseConnection]):
super().__init__(oid, conn)
self.decode: DecodeFunc
if conn is not None:
from .misc import error_message, ConninfoOption
from . import _pq_ctypes as impl
from ..exceptions import OperationalError
+from ..utils.typing import Oid
def version() -> int:
self,
command: bytes,
param_values: List[Optional[bytes]],
- param_types: Optional[List[int]] = None,
+ param_types: Optional[List[Oid]] = None,
param_formats: Optional[List[Format]] = None,
result_format: Format = Format.TEXT,
) -> "PGresult":
self,
command: bytes,
param_values: List[Optional[bytes]],
- param_types: Optional[List[int]] = None,
+ param_types: Optional[List[Oid]] = None,
param_formats: Optional[List[Format]] = None,
result_format: Format = Format.TEXT,
) -> None:
self,
command: bytes,
param_values: List[Optional[bytes]],
- param_types: Optional[List[int]] = None,
+ param_types: Optional[List[Oid]] = None,
param_formats: Optional[List[Format]] = None,
result_format: Format = Format.TEXT,
) -> Any:
self,
name: bytes,
command: bytes,
- param_types: Optional[List[int]] = None,
+ param_types: Optional[List[Oid]] = None,
) -> "PGresult":
if not isinstance(name, bytes):
raise TypeError(f"'name' must be bytes, got {type(name)} instead")
def fformat(self, column_number: int) -> Format:
return impl.PQfformat(self.pgresult_ptr, column_number) # type: ignore
- def ftype(self, column_number: int) -> int:
+ def ftype(self, column_number: int) -> Oid:
return impl.PQftype(self.pgresult_ptr, column_number) # type: ignore
def fmod(self, column_number: int) -> int:
return impl.PQfsize(self.pgresult_ptr, column_number) # type: ignore
@property
- def binary_tuples(self) -> int:
- return impl.PQbinaryTuples(self.pgresult_ptr) # type: ignore
+ def binary_tuples(self) -> Format:
+ return Format(impl.PQbinaryTuples(self.pgresult_ptr))
def get_value(
self, row_number: int, column_number: int
def nparams(self) -> int:
return impl.PQnparams(self.pgresult_ptr) # type: ignore
- def param_type(self, param_number: int) -> int:
+ def param_type(self, param_number: int) -> Oid:
return impl.PQparamtype( # type: ignore
self.pgresult_ptr, param_number
)
# Copyright (C) 2020 The Psycopg Team
import re
+from typing import Dict
+from ..utils.typing import Oid
-INVALID_OID = 0
+INVALID_OID = Oid(0)
# typname, oid, array oid, regtype
# autogenerated end
]
-type_oid = {name: oid for name, oid, _, _ in _oids_table}
+type_oid: Dict[str, Oid] = {name: Oid(oid) for name, oid, _, _ in _oids_table}
def self_update() -> None:
Typecaster,
)
from ..connection import BaseConnection
-from ..utils.typing import EncodeFunc, DecodeFunc
+from ..utils.typing import EncodeFunc, DecodeFunc, Oid
from .oids import type_oid
decode: Optional[DecodeFunc]
- def __init__(self, oid: int, conn: BaseConnection):
+ def __init__(self, oid: Oid, conn: BaseConnection):
super().__init__(oid, conn)
if conn is not None:
# Copyright (C) 2020 The Psycopg Team
-from typing import Any, Callable, Mapping, Sequence, Tuple, Union
+from typing import Any, Callable, Mapping, NewType, Sequence, Tuple, Union
+
+Oid = NewType("Oid", int)
EncodeFunc = Callable[[str], Tuple[bytes, int]]
DecodeFunc = Callable[[bytes], Tuple[str, int]]