DefPixel-PostgreSQL 0.1.5__83-py3-none-any.whl

DefPixel/DataAccessObject/Implements/PostgreSQL/Type.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+from typing import (
+	Any,
+	Callable,
+	Optional,
+	Tuple,
+	Type as PythonType,
+	Union,
+)
+
+from .Compiler import (
+	Compilable,
+	Compiler,
+	identifier,
+	qualified,
+	valuetype,
+)
+
+__all__ = (
+	'Type',
+)
+
+
+class Type(Compilable):
+	"""PostgreSQL column specification for SQL types and value conversion."""
+
+	typestr = ''
+
+	def __init__(
+		self,
+		key: Optional[str],
+		type: Union[PythonType, Tuple[PythonType, ...]],
+		typestr: Optional[str] = None,
+		va: Optional[Callable] = None,
+		null: bool = False,
+		default: Any = MISSING,
+	):
+		if not isinstance(null, bool):
+			raise TypeError('null must be a bool')
+		self.key = key
+		self.type = type
+		if typestr is not None:
+			self.typestr = typestr
+		self.validator = va
+		self.null = null
+		self.coldef = default
+		self.model: Optional[str] = None
+		self.schema: Optional[str] = None
+		return
+
+	def __init_subclass__(
+		cls,
+		typestr: Optional[str] = None,
+		**kwargs,
+	):
+		super().__init_subclass__(**kwargs)
+		if typestr is not None:
+			cls.typestr = typestr
+		return
+
+	def compile(self, compiler: Compiler) -> str:
+		if self.model is None or self.key is None:
+			raise ValueError('The column is not bound to a model')
+		if not compiler.qualify:
+			return identifier(self.key)
+		return '{}.{}'.format(qualified(self.model, self.schema), identifier(self.key))
+
+	def convert(self, value: Any) -> Any:
+		"""Convert an accepted input representation before the type check."""
+		return value
+
+	def check(self, value: Any) -> bool:
+		if isinstance(self.type, tuple):
+			types = self.type
+		else:
+			types = (self.type,)
+		if bool not in types and isinstance(value, bool):
+			return False
+		return isinstance(value, types)
+
+	def validate(self, value: Any) -> Any:
+		if value is None:
+			if not self.null:
+				raise ValueError('Column {} does not allow None'.format(self.key))
+			return None
+		if self.validator is not None:
+			value = self.validator(value)
+		value = self.convert(value)
+		if not self.check(value):
+			raise TypeError('Column {} requires a value of type {}'.format(
+				self.key,
+				' or '.join(t.__name__ for t in (self.type if isinstance(self.type, tuple) else (self.type,))),
+			))
+		return value
+
+	def adapt(self, value: Any) -> Any:
+		"""Wrap a validated value for the driver."""
+		return value
+
+	def encode(self, value: Any) -> Any:
+		value = self.validate(value)
+		return None if value is None else self.adapt(value)
+
+	def default(self) -> Optional[str]:
+		"""Render the column DEFAULT clause body in DDL literal mode."""
+		if self.coldef is MISSING:
+			return None
+		compiler = Compiler(literal=True)
+		if isinstance(self.coldef, Compilable):
+			return compiler.compile(self.coldef)
+		return compiler.bind(self.encode(self.coldef), cast=valuetype(self))

DefPixel/DataAccessObject/Implements/PostgreSQL/Types/Array.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+from collections.abc import Sequence
+from dataclasses import MISSING
+
+from ..Compiler import typename
+from ..Type import Type
+from .Size import positive
+
+__all__ = (
+	'Array',
+)
+
+
+class Array(Type, typestr='ARRAY'):
+	"""Array column of an element type; size sets declared dimensions, for example [3] or [2, 2]."""
+
+	def __init__(
+		self,
+		name=None,
+		type=None,
+		typesize=None,
+		size=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		if type is None:
+			raise ValueError('Array requires an element type')
+		element = typename(type, escape=False)
+		typesize = positive('typesize', typesize)
+		if size is None:
+			sizes = [None]
+		elif isinstance(size, Sequence) and not isinstance(size, str):
+			sizes = list(size)
+			if not sizes:
+				raise ValueError('size requires at least one dimension')
+		else:
+			sizes = [size]
+		dimensions = ''.join(
+			'[{}]'.format('' if value is None else positive('size', value))
+			for value in sizes
+		)
+		super().__init__(
+			key=name,
+			type=list,
+			typestr='{}{}{}'.format(
+				element,
+				'({})'.format(typesize) if typesize else '',
+				dimensions,
+			),
+			va=va,
+			null=null,
+			default=default,
+		)
+		return
+
+	def convert(self, value):
+		if isinstance(value, tuple):
+			return list(value)
+		return value

DefPixel/DataAccessObject/Implements/PostgreSQL/Types/Binary.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+
+from ..Type import Type
+
+__all__ = (
+	'Binary',
+)
+
+
+class Binary(Type, typestr='BYTEA'):
+	"""BYTEA column accepting bytes, bytearray, or memoryview values as bytes."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=bytes,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return
+
+	def convert(self, value):
+		if isinstance(value, (bytearray, memoryview)):
+			return bytes(value)
+		return value

DefPixel/DataAccessObject/Implements/PostgreSQL/Types/Bool.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+
+from ..Type import Type
+
+__all__ = (
+	'Bool',
+)
+
+
+class Bool(Type, typestr='BOOLEAN'):
+	"""BOOLEAN column specification."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=bool,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return

DefPixel/DataAccessObject/Implements/PostgreSQL/Types/DateTime.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+from datetime import (
+	date,
+	datetime,
+	time,
+	timezone as tz,
+)
+
+from ..Type import Type
+
+__all__ = (
+	'Timestamp',
+	'Date',
+	'Time',
+)
+
+
+class Timestamp(Type, typestr='TIMESTAMP'):
+	"""TIMESTAMP column; timezone=True requires aware values, otherwise values must be naive."""
+
+	def __init__(
+		self,
+		name=None,
+		timezone=False,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		if not isinstance(timezone, bool):
+			raise TypeError('timezone must be a bool')
+		super().__init__(
+			key=name,
+			type=datetime,
+			typestr='TIMESTAMP WITH TIME ZONE' if timezone else 'TIMESTAMP',
+			va=va,
+			null=null,
+			default=default,
+		)
+		self.timezone = timezone
+		return
+
+	def convert(self, value):
+		if isinstance(value, str):
+			return datetime.fromisoformat(value)
+		if isinstance(value, float):
+			return datetime.fromtimestamp(value, tz=tz.utc if self.timezone else None)
+		return value
+
+	def check(self, value) -> bool:
+		if not super().check(value):
+			return False
+		aware = value.tzinfo is not None and value.tzinfo.utcoffset(value) is not None
+		if aware != self.timezone:
+			raise ValueError('Column {} requires a timezone-{} datetime'.format(
+				self.key,
+				'aware' if self.timezone else 'naive',
+			))
+		return True
+
+
+class Date(Type, typestr='DATE'):
+	"""DATE column accepting date objects or ISO strings; datetime values are rejected."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=date,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return
+
+	def convert(self, value):
+		if isinstance(value, str):
+			return date.fromisoformat(value)
+		return value
+
+	def check(self, value) -> bool:
+		return super().check(value) and not isinstance(value, datetime)
+
+
+class Time(Type, typestr='TIME'):
+	"""TIME column accepting only timezone-naive time objects or ISO strings."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=time,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return
+
+	def convert(self, value):
+		if isinstance(value, str):
+			return time.fromisoformat(value)
+		return value
+
+	def check(self, value) -> bool:
+		if not super().check(value):
+			return False
+		if value.tzinfo is not None and value.utcoffset() is not None:
+			raise ValueError('Column {} requires a timezone-naive time'.format(self.key))
+		return True

DefPixel/DataAccessObject/Implements/PostgreSQL/Types/JavaScriptObjectNotation.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+
+from psycopg.types.json import (
+	Json,
+	Jsonb,
+)
+
+from ..Adapters.JavaScriptObjectNotation import encode
+from ..Type import Type
+
+__all__ = (
+	'JavaScriptObjectNotation',
+	'JavaScriptObjectNotationByteArray',
+)
+
+
+def dumps(value) -> str:
+	from json import dumps as serialize
+	return serialize(value, default=encode, allow_nan=False, ensure_ascii=False)
+
+
+class JavaScriptObjectNotation(Type, typestr='JSON'):
+	"""JSON column accepting dict or list values."""
+
+	wrapper = Json
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=(dict, list),
+			va=va,
+			null=null,
+			default=default,
+		)
+		return
+
+	def adapt(self, value):
+		return self.wrapper(value, dumps=dumps)
+
+
+class JavaScriptObjectNotationByteArray(JavaScriptObjectNotation, typestr='JSONB'):
+	"""JSONB column accepting dict or list values."""
+
+	wrapper = Jsonb

DefPixel/DataAccessObject/Implements/PostgreSQL/Types/Numeric.py

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+from decimal import Decimal as PythonDecimal
+
+from ..Type import Type
+from .Size import positive
+
+__all__ = (
+	'Short',
+	'Integer',
+	'Long',
+	'Float',
+	'Double',
+	'Decimal',
+)
+
+
+class Short(Type, typestr='SMALLINT'):
+	"""SMALLINT column specification."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=int,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return
+
+
+class Integer(Type, typestr='INTEGER'):
+	"""INTEGER column specification."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=int,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return
+
+
+class Long(Type, typestr='BIGINT'):
+	"""BIGINT column specification."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=int,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return
+
+
+class FloatingPoint(Type):
+	"""Floating-point column accepting int values as floats."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=float,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return
+
+	def convert(self, value):
+		if isinstance(value, int) and not isinstance(value, bool):
+			return float(value)
+		return value
+
+
+class Float(FloatingPoint, typestr='REAL'):
+	"""REAL column specification."""
+
+
+class Double(FloatingPoint, typestr='DOUBLE PRECISION'):
+	"""DOUBLE PRECISION column specification."""
+
+
+class Decimal(Type, typestr='NUMERIC'):
+	"""NUMERIC(precision, scale) column specification accepting int values as Decimal."""
+
+	def __init__(
+		self,
+		name=None,
+		precision=None,
+		scale=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		precision = positive('precision', precision)
+		if scale is not None:
+			if precision is None:
+				raise ValueError('scale requires precision')
+			if type(scale) is not int:
+				raise ValueError('scale must be an int')
+		if precision is None:
+			typestr = 'NUMERIC'
+		elif scale is None:
+			typestr = 'NUMERIC({})'.format(precision)
+		else:
+			typestr = 'NUMERIC({},{})'.format(precision, scale)
+		super().__init__(
+			key=name,
+			type=PythonDecimal,
+			typestr=typestr,
+			va=va,
+			null=null,
+			default=default,
+		)
+		self.precision = precision
+		self.scale = scale
+		return
+
+	def convert(self, value):
+		if isinstance(value, int) and not isinstance(value, bool):
+			return PythonDecimal(value)
+		return value

DefPixel/DataAccessObject/Implements/PostgreSQL/Types/Size.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+__all__ = (
+	'positive',
+)
+
+
+def positive(name: str, value, null: bool = True):
+	if value is None and null:
+		return None
+	if type(value) is not int or value < 1:
+		raise ValueError('{} must be a positive int'.format(name))
+	return value

DefPixel/DataAccessObject/Implements/PostgreSQL/Types/String.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+
+from ..Type import Type
+from .Size import positive
+
+__all__ = (
+	'Char',
+	'String',
+	'Text',
+)
+
+
+class Char(Type, typestr='CHAR'):
+	"""CHAR(size) column specification; PostgreSQL pads stored values with spaces."""
+
+	def __init__(
+		self,
+		name=None,
+		size=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		size = positive('size', size)
+		super().__init__(
+			key=name,
+			type=str,
+			typestr='CHAR({})'.format(size) if size else 'CHAR',
+			va=va,
+			null=null,
+			default=default,
+		)
+		self.size = size
+		return
+
+
+class String(Type, typestr='VARCHAR'):
+	"""VARCHAR(size) column specification."""
+
+	def __init__(
+		self,
+		name=None,
+		size=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		size = positive('size', size)
+		super().__init__(
+			key=name,
+			type=str,
+			typestr='VARCHAR({})'.format(size) if size else 'VARCHAR',
+			va=va,
+			null=null,
+			default=default,
+		)
+		self.size = size
+		return
+
+
+class Text(Type, typestr='TEXT'):
+	"""TEXT column specification."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=str,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return