DefPixel 0.1.0__3-py3-none-any.whl

DefPixel/DataAccessObject/Implements/Sqlite/__init__.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+from .Configuration import Configuration
+from .Connection import Connection
+from .Cursor import Cursor
+from .Session import Session
+from .Context import Context
+
+from .Mapping import (
+	column,
+	table,
+	view,
+)
+
+from .Constraint import Constraint
+from .Index import Index
+from .Expr import Expr
+from .Function import Function
+
+from sqlite3 import register_adapter
+from datetime import datetime
+
+__all__ = (
+	'Configuration',
+	'Connection',
+	'Cursor',
+	'Session',
+	'Context',
+	'column',
+	'table',
+	'view',
+	'Constraint',
+	'Index',
+	'Expr',
+	'Function',
+)
+
+
+register_adapter(datetime, datetime.isoformat)

DefPixel/DataAccessObject/Implements/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

DefPixel/DataAccessObject/Properties/Database/Context.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+from abc import abstractmethod
+from typing import (
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Context'
+)
+
+
+@runtime_checkable
+class Context(Protocol):
+	"""Protocol for database execution results."""
+
+	@abstractmethod
+	def rows(self):
+		raise NotImplementedError('{} must be implemented rows'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def row(self):
+		raise NotImplementedError('{} must be implemented row'.format(self.__class__.__name__))
+	
+	@abstractmethod
+	def count(self):
+		raise NotImplementedError('{} must be implemented count'.format(self.__class__.__name__))
+
+	@property
+	@abstractmethod
+	def query(self):
+		raise NotImplementedError('{} must be implemented query'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Properties/Database/Cursor.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+from .Context import Context
+
+from abc import abstractmethod
+from typing import (
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Cursor'
+)
+
+
+@runtime_checkable
+class Cursor(Protocol):
+	"""Protocol for database cursors."""
+
+	@abstractmethod
+	def execute(self, sql, *args, **kwargs) -> Context:
+		raise NotImplementedError('{} must be implemented execute'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def executes(self, sql, *args, **kwargs) -> Context:
+		raise NotImplementedError('{} must be implemented executes'.format(self.__class__.__name__))
+	

DefPixel/DataAccessObject/Properties/Database/Database.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+from .Context import Context
+from .Cursor import Cursor
+from .Session import Session
+
+from abc import abstractmethod
+from typing import (
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Database'
+)
+
+
+@runtime_checkable
+class Database(Protocol):
+	"""Protocol for SQL execution and transaction control."""
+
+	@abstractmethod
+	def begin(self):
+		raise NotImplementedError('{} must be implemented begin'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def execute(self, sql, *args, **kwargs) -> Context:
+		raise NotImplementedError('{} must be implemented execute'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def executes(self, sql, *args, **kwargs) -> Context:
+		raise NotImplementedError('{} must be implemented executes'.format(self.__class__.__name__))
+	
+	@abstractmethod
+	def cursor(self) -> Cursor:
+		raise NotImplementedError('{} must be implemented Cursor'.format(self.__class__.__name__))
+	
+	@abstractmethod
+	def session(self) -> Session:
+		raise NotImplementedError('{} must be implemented session'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def commit(self):
+		raise NotImplementedError('{} must be implemented commit'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def rollback(self):
+		raise NotImplementedError('{} must be implemented rollback'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Properties/Database/Executor.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+from ..Dataclass import Dataclass
+
+from abc import abstractmethod
+from typing import (
+	Union,
+	Sequence,
+	Mapping,
+	Type,
+	Protocol,
+	runtime_checkable,
+)
+
+
+__all__ = (
+	'Executor'
+)
+
+
+@runtime_checkable
+class Executor(Protocol):
+	"""Protocol exposing a query and its execution arguments."""
+
+	@abstractmethod
+	def __init__(self, o: Type[Dataclass]):
+		pass
+	
+	@property
+	@abstractmethod
+	def query(self) -> str:
+		pass
+
+	@property
+	@abstractmethod
+	def args(self) -> Union[Sequence, Mapping]:
+		pass
+	

DefPixel/DataAccessObject/Properties/Database/Executors.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+from ..Dataclass import Dataclass
+
+from .Executor import Executor
+
+from abc import abstractmethod
+
+from typing import (
+	Type,
+	Iterator,
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Executors'
+)
+
+
+@runtime_checkable
+class Executors(Protocol):
+	"""Protocol for iterating over multiple Executors."""
+
+	@abstractmethod
+	def __init__(self, o: Type[Dataclass]):
+		pass
+	
+	@abstractmethod
+	def __iter__(self) -> Iterator[Executor]:
+		pass

DefPixel/DataAccessObject/Properties/Database/Fetch.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+
+from ..Dataclass import Dataclass
+
+from abc import abstractmethod
+
+from .Filter import Filter
+
+from typing import (
+	Union,
+	Dict,
+	List,
+	Type,
+	TypeVar,
+	Optional,
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Fetch'
+)
+
+T = TypeVar('T', bound=Dataclass)
+
+
+@runtime_checkable
+class Fetch(Protocol):
+	"""Protocol for converting query results into models or dictionaries."""
+	@abstractmethod
+	def fetch(
+		self,
+		cursor,
+		filter: Optional[Filter] = None,
+		fetch: Optional[Type[T]] = None,
+	) -> Optional[Union[Dict, T, List[Dict], List[T]]]:
+		raise NotImplementedError('{} must be implemented fetch'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Properties/Database/Filter.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+from abc import abstractmethod
+
+from typing import (
+	Dict,
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Filter',
+)
+
+
+@runtime_checkable
+class Filter(Protocol):
+	"""Callable protocol for transforming result rows."""
+	@abstractmethod
+	def __call__(self, row: Dict) -> Dict:
+		raise NotImplementedError('{} must be implemented __call__'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Properties/Database/Run.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+from ..Dataclass import Dataclass
+
+from abc import abstractmethod
+
+from .Executors import Executors
+from .Executor import Executor
+from .Filter import Filter
+
+from typing import (
+	Optional,
+	Type,
+	TypeVar,
+	Union,
+	List,
+	Dict,
+	Protocol,
+	runtime_checkable,
+)
+
+T = TypeVar('T', bound=Dataclass)
+
+__all__ = (
+	'Run'
+)
+
+
+@runtime_checkable
+class Run(Protocol):
+	"""Protocol for executing Executors."""
+	@abstractmethod
+	def run(
+		self,
+		executor: Union[Executor, Executors],
+		filter: Optional[Filter] = None,
+		fetch: Optional[Type[T]] = None,
+	) -> Optional[Union[T, List[T], Dict, List[Dict]]]:
+		raise NotImplementedError('{} must be implemented run'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Properties/Database/Session.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+from abc import abstractmethod
+from typing import (
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Session'
+)
+
+
+@runtime_checkable
+class Session(Protocol):
+	"""Protocol for database sessions."""
+
+	@abstractmethod
+	def execute(self, sql, *args, **kwargs):
+		raise NotImplementedError('{} must be implemented execute'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def executes(self, sql, *args, **kwargs):
+		raise NotImplementedError('{} must be implemented execute'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def rows(self):
+		raise NotImplementedError('{} must be implemented rows'.format(self.__class__.__name__))
+	
+	@abstractmethod
+	def row(self):
+		raise NotImplementedError('{} must be implemented row'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def count(self):
+		raise NotImplementedError('{} must be implemented count'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Properties/Database/__init__.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+from .Database import Database
+from .Context import Context
+from .Cursor import Cursor
+from .Session import Session
+
+from .Executor import Executor
+from .Executors import Executors
+
+from .Run import Run
+from .Fetch import Fetch
+from .Filter import Filter
+
+__all__ = (
+	'Database',
+	'Context',
+	'Cursor',
+	'Session',
+	'Run',
+	'Filter',
+	'Executor',
+	'Executors',
+	'Fetch',
+)

DefPixel/DataAccessObject/Properties/Dataclass.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+from dataclasses import Field
+from typing import (
+	Any,
+	ClassVar,
+	Dict,
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Dataclass',
+)
+
+
+@runtime_checkable
+class Dataclass(Protocol):
+	"""Structural type contract exposing standard dataclass field information.
+
+	Inheritance is not required, and this contract does not guarantee dataclass identity at runtime.
+	DAO implementations must validate inputs using is_dataclass().
+	"""
+
+	__dataclass_fields__: ClassVar[Dict[str, Field[Any]]]

DefPixel/DataAccessObject/Properties/Document/Document.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+from abc import abstractmethod
+from typing import (
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Document'
+)
+
+
+@runtime_checkable
+class Document(Protocol):
+	"""Protocol for document storage and retrieval."""
+
+	@abstractmethod
+	def create(self, doc, **kwargs):
+		raise NotImplementedError('{} must be implemented create'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def set(self, doc, **kwargs):
+		raise NotImplementedError('{} must be implemented set'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def get(self, doc, **kwargs):
+		raise NotImplementedError('{} must be implemented get'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def query(self, doc, **kwargs):
+		raise NotImplementedError('{} must be implemented find'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def remove(self, doc, **kwargs):
+		raise NotImplementedError('{} must be implemented remove'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Properties/Document/__init__.py

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

DefPixel/DataAccessObject/Properties/Index/Index.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+from abc import abstractmethod
+from typing import (
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'Index'
+)
+
+
+@runtime_checkable
+class Index(Protocol):
+	"""Protocol for index-based storage and search."""
+
+	@abstractmethod
+	def create(self, index, *args, **kwargs):
+		raise NotImplementedError('{} must be implemented create'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def delete(self, index):
+		raise NotImplementedError('{} must be implemented delete'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def total(self, index):
+		raise NotImplementedError('{} must be implemented count'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def set(self, index, *args, **kwargs):
+		raise NotImplementedError('{} must be implemented set'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def get(self, index, id):
+		raise NotImplementedError('{} must be implemented get'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def exists(self, index, id):
+		raise NotImplementedError('{} must be implemented exists'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def count(self, index, *args, **kwargs):
+		raise NotImplementedError('{} must be implemented search'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def query(self, index, *args, **kwargs):
+		raise NotImplementedError('{} must be implemented search'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Properties/Index/__init__.py

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

DefPixel/DataAccessObject/Properties/KeyValue/KeyValue.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+
+from abc import abstractmethod
+from typing import (
+	Protocol,
+	runtime_checkable,
+)
+
+__all__ = (
+	'KeyValue'
+)
+
+
+@runtime_checkable
+class KeyValue(Protocol):
+	"""Protocol for key-value storage and expiration management."""
+
+	@abstractmethod
+	def keys(self, key):
+		raise NotImplementedError('{} must be implemented keys'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def exists(self, key):
+		raise NotImplementedError('{} must be implemented exist'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def get(self, key):
+		raise NotImplementedError('{} must be implemented get'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def set(self, key, value, expires=None):
+		raise NotImplementedError('{} must be implemented set'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def expire(self, key, seconds):
+		raise NotImplementedError('{} must be implemented expire'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def persist(self, key):
+		raise NotImplementedError('{} must be implemented persist'.format(self.__class__.__name__))
+
+	@abstractmethod
+	def delete(self, key):
+		raise NotImplementedError('{} must be implemented delete'.format(self.__class__.__name__))

DefPixel/DataAccessObject/Properties/KeyValue/__init__.py

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

DefPixel/DataAccessObject/Properties/__init__.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+from .Database import Database
+from .Document import Document
+from .Index import Index
+from .KeyValue import KeyValue
+from .Dataclass import Dataclass
+
+__all__ = (
+	'Database',
+	'Document',
+	'Index',
+	'KeyValue',
+	'Dataclass',
+)

DefPixel/DataAccessObject/__init__.py

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

DefPixel/Validator/Pattern.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+from abc import (
+	ABC,
+	abstractmethod,
+)
+
+__all__ = (
+	'Pattern',
+)
+
+
+class Pattern(ABC):
+	"""
+	Pattern Interface Class for Validator
+
+	Sample:
+	from operator import eq
+
+	class SamplePattern(Pattern):
+		def __init__(self, compare):
+			super(SamplePattern, self).__init__(error)
+			self.compare = compare
+			return
+
+		def __call__(self, parameter):
+			if not eq(parameter, self.compare):
+				raise ValueError('{} is not equal to {}'.format(parameter, self.condition))
+			return parameter  # if true, return parameter
+	"""
+	@abstractmethod
+	def __call__(self, parameter):
+		pass
+
+	def __repr__(self):
+		return '{}()'.format(self.__class__.__name__)

DefPixel/Validator/Patterns/Array.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from typing import Any
+
+__all__ = (
+	'IsElementOf',
+)
+
+
+class IsElementOf(Pattern):
+	def __init__(self, *args):
+		self.patterns = args
+		return
+
+	def __call__(self, parameter: Any) -> Any:
+		_ = list(parameter)
+		for pattern in self.patterns:
+			for i, e in enumerate(_):
+				_[i] = pattern(e)
+		return type(parameter)(_)
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(p) for p in self.patterns]
+			)
+		)