DefPixel 0.1.0__3-py3-none-any.whl

DefPixel/DataAccessObject/Implements/Sqlite/Joins/LeftOuter.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+from .Join import Join
+
+from DefPixel.DataAccessObject.Properties import Dataclass
+
+from typing import Type
+
+__all__ = (
+	'LeftOuter'
+)
+
+
+class LeftOuter(Join):
+	"""Left Outer Class"""
+
+	def __init__(self, table: Type[Dataclass], *args) -> None:
+		super(LeftOuter, self).__init__('LEFT OUTER', table, *args)
+		return

DefPixel/DataAccessObject/Implements/Sqlite/Joins/RightOuter.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+from .Join import Join
+
+from DefPixel.DataAccessObject.Properties import Dataclass
+
+from typing import Type
+
+__all__ = (
+	'RightOuter'
+)
+
+
+class RightOuter(Join):
+	"""Right Outer Join Class"""
+
+	def __init__(self, table: Type[Dataclass], *args) -> None:
+		super(RightOuter, self).__init__('RIGHT OUTER', table, *args)
+		return

DefPixel/DataAccessObject/Implements/Sqlite/Joins/__init__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+from .Inner import Inner
+from .LeftOuter import LeftOuter
+from .RightOuter import RightOuter
+from .FullOuter import FullOuter
+
+__all__ = (
+	'Inner',
+	'LeftOuter',
+	'RightOuter',
+	'FullOuter',
+)

DefPixel/DataAccessObject/Implements/Sqlite/Mapping.py

@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+
+from copy import copy
+from dataclasses import (
+	MISSING,
+	field,
+	fields,
+	is_dataclass,
+)
+from types import MemberDescriptorType
+from typing import (
+	Any,
+	Callable,
+	Dict,
+	NamedTuple,
+	Optional,
+	Sequence,
+	Type as PythonType,
+	TypeVar,
+)
+
+from .Type import Type
+from .Constraint import Constraint
+from .Index import Index
+
+__all__ = (
+	'column',
+	'table',
+	'view',
+)
+
+METADATA = 'defpixel.sqlite'
+MAPPING = '__defpixel_sqlite__'
+T = TypeVar('T')
+
+
+def identifier(name: str) -> str:
+	if not isinstance(name, str) or not name or '\x00' in name:
+		raise ValueError('SQL identifiers must be nonempty strings without null characters')
+	return '"{}"'.format(name.replace('"', '""'))
+
+
+class Statement(NamedTuple):
+	"""Satisfy the single-execution contract while preserving query and argument unpacking."""
+
+	query: str
+	args: Sequence[Any] = ()
+
+
+class ColumnAccess:
+	"""Expose a column on class access and a standard field value on instance access."""
+
+	def __init__(
+		self,
+		name: str,
+		spec: Type,
+		original: Any,
+		default: Any,
+	):
+		self.name = name
+		self.spec = spec
+		self.original = original
+		self.default = default
+		return
+
+	def __get__(
+		self,
+		instance,
+		owner=None,
+	):
+		if instance is None:
+			return self.spec
+		if self.original is not None:
+			return self.original.__get__(instance, owner)
+		if self.name in instance.__dict__:
+			return instance.__dict__[self.name]
+		if self.default is not MISSING:
+			return self.default
+		raise AttributeError(self.name)
+
+	def __set__(
+		self,
+		instance,
+		value,
+	):
+		if self.original is not None:
+			self.original.__set__(instance, value)
+		else:
+			instance.__dict__[self.name] = value
+		return
+
+	def __delete__(self, instance):
+		if self.original is not None:
+			self.original.__delete__(instance)
+		else:
+			try:
+				del instance.__dict__[self.name]
+			except KeyError:
+				raise AttributeError(self.name) from None
+		return
+
+
+class Mapping:
+	"""Explicit mapping between a dataclass and SQLite storage."""
+
+	def __init__(
+		self,
+		model: PythonType,
+		name: str,
+		kind: str,
+		columns: Dict[str, Type],
+		constraints: Sequence,
+		indexes: Sequence,
+		executor=None,
+		description=None,
+	):
+		self.model = model
+		self.name = name
+		self.kind = kind
+		self.columns = columns
+		self.constraints = constraints
+		self.indexes = indexes
+		self.executor = executor
+		self.description = description
+		return
+
+	def values(self, values):
+		unknown = set(values) - self.columns.keys()
+		if unknown:
+			raise ValueError('Unmapped fields: {}'.format(', '.join(sorted(unknown))))
+		return {
+			self.columns[name].key: self.columns[name].encode(value)
+			for name, value in values.items()
+		}
+
+	def restore(self, row):
+		members = {member.name: member for member in fields(self.model)}
+		values = {}
+		deferred = {}
+		by_column = {spec.key: name for name, spec in self.columns.items()}
+		for key, value in row.items():
+			if key not in by_column:
+				raise ValueError('Result column is not mapped to the model: {}'.format(key))
+			name = by_column[key]
+			value = self.columns[name].validate(value)
+			if members[name].init:
+				values[name] = value
+			else:
+				deferred[name] = value
+		for name, member in members.items():
+			if (
+				member.init and name not in values
+				and member.default is MISSING and member.default_factory is MISSING
+			):
+				raise ValueError('Missing field required for object restoration: {}'.format(name))
+		instance = self.model(**values)
+		for name, value in deferred.items():
+			object.__setattr__(instance, name, value)
+		return instance
+
+
+def column(
+	spec: Type,
+	*,
+	validator=None,
+	description: Optional[str] = None,
+) -> Any:
+	"""Attach a SQLite specification and its default to a standard Field."""
+	if not isinstance(spec, Type):
+		raise TypeError('column requires a SQLite Type specification')
+	spec = copy(spec)
+	if validator is not None:
+		spec.validator = validator
+	return field(
+		default=spec.coldef,
+		metadata={
+			METADATA: spec,
+			'description': description,
+		},
+	)
+
+
+def inspect_model(
+	model: PythonType,
+	kind: Optional[str] = None,
+) -> Mapping:
+	if not isinstance(model, type) or not is_dataclass(model):
+		raise TypeError('ORM models must be dataclass classes')
+	mapping = vars(model).get(MAPPING)
+	if not isinstance(mapping, Mapping) or mapping.model is not model:
+		raise ValueError('{} has no @table or @view mapping'.format(model.__name__))
+	if kind is not None and mapping.kind != kind:
+		raise ValueError('A {} operation cannot use a {} mapping'.format(kind, mapping.kind))
+	return mapping
+
+
+def mapped(
+	model: PythonType[T],
+	name,
+	kind,
+	constraints,
+	indexes,
+	executor,
+	description,
+) -> PythonType[T]:
+	if not isinstance(model, type) or not is_dataclass(model):
+		raise TypeError('@{} must be applied after @dataclass'.format(kind))
+	if MAPPING in vars(model):
+		raise ValueError('The model already has a SQLite mapping')
+	identifier(model.__name__ if name is None else name)
+	columns = {}
+	accessors = {}
+	keys = set()
+	for member in fields(model):
+		if member.name == MAPPING:
+			raise ValueError('The reserved mapping attribute cannot be used as a field name')
+		if METADATA not in member.metadata:
+			continue
+		spec = copy(member.metadata[METADATA])
+		spec.key = member.name if spec.key is None else spec.key
+		identifier(spec.key)
+		if spec.key in keys:
+			raise ValueError('Duplicate column: {}'.format(spec.key))
+		keys.add(spec.key)
+		spec.model = model.__name__ if name is None else name
+		columns[member.name] = spec
+		original = None
+		for base in model.__mro__:
+			attribute = vars(base).get(member.name)
+			if isinstance(attribute, ColumnAccess):
+				original = attribute.original
+				break
+			if isinstance(attribute, MemberDescriptorType):
+				original = attribute
+				break
+		accessors[member.name] = ColumnAccess(
+			member.name,
+			spec,
+			original,
+			member.default,
+		)
+	if not columns:
+		raise ValueError('No fields are declared with column()')
+	mapping = Mapping(
+		model,
+		model.__name__ if name is None else name,
+		kind,
+		columns,
+		(constraints,) if isinstance(constraints, Constraint) else tuple(constraints or ()),
+		(indexes,) if isinstance(indexes, Index) else tuple(indexes or ()),
+		executor,
+		description,
+	)
+	setattr(model, MAPPING, mapping)
+	for key, accessor in accessors.items():
+		setattr(model, key, accessor)
+	return model
+
+
+def table(
+	name=None,
+	*,
+	constraints=None,
+	indexes=None,
+	description=None,
+) -> Callable[[PythonType[T]], PythonType[T]]:
+	"""Map a processed dataclass to a table and return the same class."""
+	def decorate(model: PythonType[T]) -> PythonType[T]:
+		return mapped(
+			model,
+			name,
+			'table',
+			constraints,
+			indexes,
+			None,
+			description,
+		)
+	return decorate
+
+
+def view(
+	*,
+	executor,
+	name=None,
+	description=None,
+) -> Callable[[PythonType[T]], PythonType[T]]:
+	"""Map a processed dataclass to a view defined by a query Executor."""
+	def decorate(model: PythonType[T]) -> PythonType[T]:
+		from DefPixel.DataAccessObject.Properties.Database import Executor
+		if not isinstance(executor, Executor):
+			raise TypeError('View definitions require a single Executor')
+		if executor.args:
+			raise ValueError('SQLite view definitions cannot contain bound parameters')
+		return mapped(
+			model,
+			name,
+			'view',
+			None,
+			None,
+			executor,
+			description,
+		)
+	return decorate

DefPixel/DataAccessObject/Implements/Sqlite/Orders/Ascend.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+from ..Expr import Expr
+
+from ..Type import Type
+
+__all__ = (
+	'Ascend'
+)
+
+
+class Ascend(Expr):
+	"""Ascend Order Class"""
+
+	def __init__(self, col: Type, null='LAST') -> None:
+		self.col = col
+		self.null = null
+		return
+
+	def __str__(self):
+		return '{} ASC{}'.format(
+			str(self.col) if isinstance(self.col, Type) else self.col,
+			' NULLS {}'.format(self.null) if self.null else '',
+		)

DefPixel/DataAccessObject/Implements/Sqlite/Orders/Descend.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+from ..Expr import Expr
+
+from ..Type import Type
+
+__all__ = (
+	'Descend'
+)
+
+
+class Descend(Expr):
+	"""Descend Order Class"""
+
+	def __init__(self, col: Type, null='LAST') -> None:
+		self.col = col
+		self.null = null
+		return
+
+	def __str__(self):
+		return '{} DESC{}'.format(
+			str(self.col) if isinstance(self.col, Type) else self.col,
+			' NULLS {}'.format(self.null) if self.null else '',
+		)

DefPixel/DataAccessObject/Implements/Sqlite/Orders/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+from .Ascend import Ascend
+from .Descend import Descend
+
+__all__ = (
+	'Ascend',
+	'Descend',
+)

DefPixel/DataAccessObject/Implements/Sqlite/Session.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+from DefPixel.DataAccessObject.Properties.Database import Session as BaseSession
+from .Cursor import Cursor
+
+__all__ = (
+	'Session',
+)
+
+
+class Session(Cursor, BaseSession):
+	"""Explicit cursor scope sharing the connection transaction."""
+
+	def __init__(self, connection):
+		self.connection = connection
+		super().__init__(connection.cursor())
+		return
+
+	def __enter__(self):
+		if not self.connection.in_transaction:
+			self.connection.execute('BEGIN')
+		return self
+
+	def __exit__(
+		self,
+		exception_type,
+		exception,
+		traceback,
+	):
+		try:
+			if exception_type is None:
+				self.connection.commit()
+			else:
+				self.connection.rollback()
+		finally:
+			self.close()
+		return False

DefPixel/DataAccessObject/Implements/Sqlite/Type.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+from datetime import datetime
+from typing import (
+	Any,
+	Callable,
+	Optional,
+	Type as PythonType,
+)
+
+__all__ = (
+	'Type',
+)
+
+
+class Type:
+	"""SQLite column specification for storage types and value conversion."""
+
+	typestr = ''
+
+	def __init__(
+		self,
+		key: Optional[str],
+		type: PythonType,
+		va: Optional[Callable] = None,
+		null: bool = False,
+		default: Any = MISSING,
+	):
+		self.key = key
+		self.type = type
+		self.validator = va
+		self.null = null
+		self.coldef = default
+		self.model: Optional[str] = None
+		return
+
+	def __init_subclass__(
+		cls,
+		typestr: str,
+	):
+		super().__init_subclass__()
+		cls.typestr = typestr
+		return
+
+	def __str__(self) -> str:
+		if self.model is None or self.key is None:
+			raise ValueError('The column is not bound to a model')
+		from .Mapping import identifier
+		return '{}.{}'.format(identifier(self.model), identifier(self.key))
+
+	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)
+		if not isinstance(value, self.type) or (
+			self.type is int and isinstance(value, bool)
+		):
+			raise TypeError('Column {} requires a value of type {}'.format(self.key, self.type.__name__))
+		return value
+
+	def encode(
+		self,
+		value: Any,
+	) -> Any:
+		value = self.validate(value)
+		if isinstance(value, datetime):
+			return value.isoformat()
+		return value

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

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

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

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+from datetime import datetime
+from ..Type import Type
+
+__all__ = (
+	'DateTime',
+	'Timestamp',
+)
+
+
+def to_datetime(value):
+	if isinstance(value, str):
+		return datetime.fromisoformat(value)
+	if isinstance(value, float):
+		return datetime.fromtimestamp(value)
+	return value
+
+
+class DateTime(Type, typestr='DATETIME'):
+	"""Date-time specification supporting ISO string and float timestamp conversion."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=datetime,
+			va=to_datetime if va is None else va,
+			null=null,
+			default=default,
+		)
+		return
+
+
+class Timestamp(DateTime, typestr='TIMESTAMP'):
+	"""Date-time specification using a TIMESTAMP declaration."""

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

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+from ..Type import Type
+
+__all__ = (
+	'Integer',
+	'Float',
+)
+
+
+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 Float(Type, typestr='REAL'):
+	"""Floating-point column specification."""
+
+	def __init__(
+		self,
+		name=None,
+		va=None,
+		null=False,
+		default=MISSING,
+	):
+		super().__init__(
+			key=name,
+			type=float,
+			va=va,
+			null=null,
+			default=default,
+		)
+		return

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

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING
+from ..Type import Type
+
+__all__ = (
+	'Text',
+)
+
+
+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

DefPixel/DataAccessObject/Implements/Sqlite/Types/__init__.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+from .Numeric import (
+	Integer,
+	Float,
+)
+from .String import Text
+from .Binary import Binary
+from .DateTime import (
+	DateTime,
+	Timestamp,
+)
+
+__all__ = (
+	'Integer', 'INTEGER',
+	'Float', 'FLOAT', 'REAL',
+	'Text', 'TEXT', 'STRING',
+	'Binary', 'BLOB',
+	'DateTime', 'DATETIME',
+	'Timestamp', 'TIMESTAMP',
+)
+
+# NUMERIC
+INTEGER = Integer
+FLOAT = Float
+REAL = Float
+# TEXT
+TEXT = Text
+STRING = Text
+# BINARY
+BLOB = Binary
+# DATETIME
+DATETIME = DateTime
+TIMESTAMP = Timestamp