DefEssential 0.1.8__24-py3-none-any.whl

DefEssential/Validator/Patterns/Size.py

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from operator import ne, le, ge, gt, lt
+
+__all__ = (
+	'IsSizeOf',
+	'IsSizeIn',
+	'IsMaxSizeOf',
+	'IsMinSizeOf',
+)
+
+
+class IsSizeOf(Pattern):
+	def __init__(self, size : int, error=None):
+		self.size = size
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if ne(len(parameter), self.size):
+			if self.error:
+				raise self.error
+			raise ValueError(
+				'{} must be size of {}'.format(
+					parameter, 
+					self.size
+				)
+			)
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.size
+		)
+
+
+class IsSizeIn(Pattern):
+	def __init__(self, size : int, min : int = 0, error=None):
+		self.size = size
+		self.min = min 
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if lt(len(parameter), self.min) or gt(len(parameter), self.size):
+			if self.error:
+				raise self.error
+			raise ValueError(
+				'{} must be size from {} to {}'.format(
+					parameter, 
+					self.min,
+					self.size,
+				)
+			)
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.size
+		)
+
+
+class IsMaxSizeOf(Pattern):
+	def __init__(self, size : int, error=None):
+		self.size = size
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if gt(len(parameter), self.size):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be maxium size of {}'.format(
+				parameter,
+				self.size
+			))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.size
+		)
+	
+
+class IsMinSizeOf(Pattern):
+	def __init__(self, size : int, error=None):
+		self.size = size
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if lt(len(parameter), self.size):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be minium size of {}'.format(
+				parameter,
+				self.size
+			))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.size
+		)

DefEssential/Validator/Patterns/String.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from operator import eq
+
+__all__ = (
+	'IsAlphabet',
+	'IsAlphaNumeric',
+	'IsNumeric',
+	'ToUpper',
+	'ToLower',
+	'IsSubString',
+)
+
+
+class IsAlphabet(Pattern):
+	def __init__(self, error=None):
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not parameter.isalpha():
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be alphabet'.format(parameter))
+		return parameter
+
+
+class IsAlphaNumeric(Pattern):
+	def __init__(self, error=None):
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not parameter.isalnum():
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be alphanumeric'.format(parameter))
+		return parameter
+	
+
+class IsNumeric(Pattern):
+	def __init__(self, error=None):
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not parameter.isnumeric():
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be numeric'.format(parameter))
+		return parameter
+
+
+class ToUpper(Pattern):
+	def __call__(self, parameter):
+		return parameter.upper()
+
+	def __repr__(self):
+		return '{}()'.format(self.__class__.__name__)
+
+
+class ToLower(Pattern):
+	def __call__(self, parameter):
+		return parameter.lower()
+
+	def __repr__(self):
+		return '{}()'.format(self.__class__.__name__)
+
+
+class IsSubString(Pattern):
+	def __init__(self, match: str, end: int = None, start: int = 0, error=None):
+		self.error = error
+		self.match = match
+		self.start = start
+		self.end = end if end is not None else len(match)
+		return
+	
+	def __call__(self, parameter):
+		if not eq(parameter[self.start:self.end], self.match):
+			if self.error:
+				raise self.error
+			raise ValueError('{} is not substring to {}'.format(parameter[self.start:self.end], self.match))
+		return parameter

DefEssential/Validator/Patterns/Type.py

@@ -0,0 +1,350 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+from ast import literal_eval
+from collections.abc import (
+	Iterable,
+	Mapping,
+)
+from typing import Type, Sequence, Union
+
+__all__ = (
+	'IsTypeOf',
+	'IsBool',
+	'IsInteger',
+	'IsFloat',
+	'IsNumber',
+	'IsString',
+	'IsList',
+	'IsTuple',
+	'IsSet',
+	'IsArray',
+	'IsObject',
+	'IsByteString',
+	'IsByteArray',
+	'IsDecimal',
+	'IsDataObject',
+	'ToTypeOf',
+	'ToBool',
+	'ToInteger',
+	'ToFloat',
+	'ToString',
+	'ToList',
+	'ToTuple',
+	'ToSet',
+	'ToObject',
+	'ToByteString',
+	'ToByteArray',
+	'ToDecimal',
+	'ToDataObject',
+)
+
+
+class IsTypeOf(Pattern):
+	def __init__(
+		self, 
+		type: Union[Type, Sequence[Type]],
+		patterns: Sequence[Pattern] = (),
+		error: BaseException = None
+	):
+		self.type = type
+		self.patterns = patterns if isinstance(patterns, Iterable) else (patterns,)
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		def op(parameter):
+			if isinstance(self.type, Iterable):
+				return isinstance(parameter, self.type)
+			return type(parameter) is self.type
+		if not op(parameter):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be {}'.format(
+				'\'{}\''.format(parameter) if isinstance(parameter, str) else parameter, 
+				', '.join([t.__name__ for t in self.type]) if isinstance(self.type, Iterable) else self.type.__name__
+			))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter
+
+	def __repr__(self):
+		if issubclass(self.__class__, IsTypeOf):	
+			return '{}({})'.format(
+				self.__class__.__name__,
+				', '.join([p.__repr__() for p in self.patterns]) if self.patterns and len(self.patterns) else ''
+			)
+		return '{}({}{})'.format(
+			self.__class__.__name__,
+			self.type.__name__,
+			', ({})'.format(
+				', '.join([p.__repr__() for p in self.patterns])
+			) if self.patterns and len(self.patterns) else ''
+		)
+
+
+class IsBool(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(bool, patterns=args, error=error)
+		return
+
+
+class IsInteger(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(int, patterns=args, error=error)
+		return
+
+
+class IsFloat(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(float, patterns=args, error=error)
+		return
+
+
+class IsNumber(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__((int, float), patterns=args, error=error)
+		return
+
+
+class IsString(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(str, patterns=args, error=error)
+		return
+
+
+class IsList(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(list, patterns=args, error=error)
+		return
+
+
+class IsTuple(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(tuple, patterns=args, error=error)
+		return
+
+
+class IsSet(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(set, patterns=args, error=error)
+		return
+
+
+class IsArray(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter: Iterable) -> Iterable:
+		if not isinstance(parameter, Iterable) or isinstance(parameter, (str, bytes)):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be a non-string, non-bytes iterable'.format(parameter))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join([p.__repr__() for p in self.patterns])
+		)
+
+
+class IsObject(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(dict, patterns=args, error=error)
+		return
+
+
+class IsByteString(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(bytes, patterns=args, error=error)
+		return
+
+
+class IsByteArray(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(bytearray, patterns=args, error=error)
+		return
+	
+
+class IsDecimal(IsTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		from decimal import Decimal
+		super().__init__(Decimal, patterns=args, error=error)
+		return
+
+
+class IsDataObject(Pattern):
+	def __init__(
+		self, 
+		*patterns: Pattern,
+		error: BaseException = None
+	):
+		self.patterns = patterns if isinstance(patterns, Iterable) else (patterns,)
+		self.error = error
+		return
+
+	def __call__(self, parameter: object) -> object:
+		from dataclasses import is_dataclass
+		if not is_dataclass(parameter.__class__):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be dataclass'.format(
+				'\'{}\''.format(parameter) if isinstance(parameter, str) else parameter, 
+			))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter	
+
+
+class ToTypeOf(Pattern):
+	def __init__(
+		self,
+		type : type,
+		patterns: Sequence[Pattern] = (),
+		error: BaseException = None,
+		eval: bool = False,
+	):
+		self.type = type
+		self.patterns = patterns if isinstance(patterns, Iterable) else (patterns,)
+		self.error = error
+		self.eval = eval
+		return
+
+	def __call__(self, parameter):
+		try:
+			if self.eval:
+				parameter = self.type(
+					literal_eval(str(parameter))
+				)
+			else:
+				parameter = self.type(parameter)
+		except Exception as e:
+			if self.error:
+				raise self.error
+			raise ValueError('{} cannot be converted to {}'.format(
+				'\'{}\''.format(parameter) if isinstance(parameter, str) else parameter, 
+				self.type.__name__,
+			))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter
+
+	def __repr__(self):
+		if issubclass(self.__class__, ToTypeOf):	
+			return '{}({})'.format(
+				self.__class__.__name__,
+				', '.join([p.__repr__() for p in self.patterns]) if self.patterns and len(self.patterns) else ''
+			)
+		return '{}({}{})'.format(
+			self.__class__.__name__,
+			self.type.__name__,
+			', ({})'.format(
+				', '.join([p.__repr__() for p in self.patterns])
+			) if self.patterns and len(self.patterns) else ''
+		)
+
+
+class ToBool(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(bool, patterns=args, error=error, eval=True)
+		return
+
+
+class ToInteger(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(int, patterns=args, error=error, eval=True)
+		return
+
+
+class ToFloat(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(float, patterns=args, error=error, eval=True)
+		return
+
+
+class ToString(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(str, patterns=args, error=error)
+		return
+
+
+class ToList(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(list, patterns=args, error=error)
+		return
+
+
+class ToTuple(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(tuple, patterns=args, error=error)
+		return
+	
+
+class ToSet(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(set, patterns=args, error=error)
+		return
+
+
+class ToObject(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(dict, patterns=args, error=error)
+		return
+
+
+class ToByteString(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(bytes, patterns=args, error=error)
+		return
+
+
+class ToByteArray(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		super().__init__(bytearray, patterns=args, error=error)
+		return
+
+
+class ToDecimal(ToTypeOf):
+	def __init__(self, *args, error: BaseException = None):
+		from decimal import Decimal
+		super().__init__(Decimal, patterns=args, error=error)
+		return
+
+
+class ToDataObject(Pattern):
+	def __init__(
+		self, 
+		*patterns: Pattern,
+		error: BaseException = None
+	):
+		self.patterns = patterns if isinstance(patterns, Iterable) else (patterns,)
+		self.error = error
+		return
+
+	def __call__(self, parameter: Mapping) -> object:
+		from dataclasses import is_dataclass, make_dataclass
+		try:
+			parameter = make_dataclass(
+				'DynamicDataClass',
+				[(key, type(value)) for key, value in parameter.items()]
+			)(**parameter)
+		except Exception as e:
+			if self.error:
+				raise self.error
+			raise ValueError('{} cannot be converted to dataclass'.format(
+				'\'{}\''.format(parameter) if isinstance(parameter, str) else parameter
+			))
+		if not is_dataclass(parameter.__class__):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be dataclass'.format(
+				'\'{}\''.format(parameter) if isinstance(parameter, str) else parameter, 
+			))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter

DefEssential/Validator/Patterns/__init__.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+
+# COMMON
+from .Common import (
+	SetDefault,
+	IsOptional,
+	IsNotToNone,
+	IsNotEmpty,
+)
+
+# SIZE
+from .Size import (
+	IsSizeOf, 
+	IsSizeIn,
+	IsMinSizeOf,
+	IsMaxSizeOf,
+)
+
+# COMPARE
+from .Compare import (
+	IsEqualTo,
+	IsNotEqualTo,
+	IsGreaterThan,
+	IsGreaterEqualTo,
+	IsLessEqualTo,
+	IsLessThan,
+	IsIn,
+	IsNotIn,
+)
+
+# CONDITION
+from .Condition import (
+	All,
+	Any,
+)
+
+# TYPE
+from .Type import (
+	IsTypeOf,
+	IsBool,
+	IsInteger,
+	IsFloat,
+	IsNumber,
+	IsString,
+	IsList,
+	IsTuple,
+	IsSet,
+	IsArray,
+	IsObject,
+	IsByteString,
+	IsByteArray,
+	IsDecimal,
+	IsDataObject,
+	ToTypeOf,
+	ToBool,
+	ToInteger,
+	ToFloat,
+	ToString,
+	ToList,
+	ToTuple,
+	ToSet,
+	ToObject,
+	ToByteString,
+	ToByteArray,
+	ToDecimal,
+	ToDataObject,
+)
+from .DateTime import (
+	IsDateTime,
+	IsDate,
+	IsTime,
+	ToDateTime,
+	ToDate,
+	ToTime,
+)
+
+
+__all__ = (
+	# COMMON
+	'SetDefault',
+	'IsOptional',
+	'IsNotToNone',
+	'IsNotEmpty',
+	# SIZE
+	'IsSizeOf',
+	'IsSizeIn',
+	'IsMinSizeOf',
+	'IsMaxSizeOf',
+	# COMPARE
+	'IsEqualTo',
+	'IsNotEqualTo',
+	'IsGreaterThan',
+	'IsGreaterEqualTo',
+	'IsLessEqualTo',
+	'IsLessThan',
+	'IsIn',
+	'IsNotIn',
+	# CONDITION
+	'All',
+	'Any',
+	# TYPE
+	'IsTypeOf',
+	'IsBool',
+	'IsInteger',
+	'IsFloat',
+	'IsNumber',
+	'IsString',
+	'IsList',
+	'IsTuple',
+	'IsSet',
+	'IsArray',
+	'IsObject',
+	'IsByteString',
+	'IsByteArray',
+	'IsDecimal',
+	'IsDataObject',
+	'ToTypeOf',
+	'ToBool',
+	'ToInteger',
+	'ToFloat',
+	'ToString',
+	'ToList',
+	'ToTuple',
+	'ToSet',
+	'ToObject',
+	'ToByteString',
+	'ToByteArray',
+	'ToDecimal',
+	'ToDataObject',
+	# DateTime
+	'IsDateTime',
+	'IsDate',
+	'IsTime',
+	'ToDateTime',
+	'ToDate',
+	'ToTime',
+)

DefEssential/Validator/Validate.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+from .Validator import Validator
+from .Patterns import IsObject
+from .Patterns.Object import IsMappingOf
+
+from functools import wraps
+from inspect import signature
+
+__all__ = (
+	'Validate',
+)
+
+
+class Validate(object):
+	"""Decorator for Validator of Function and Method"""
+	def __init__(self, mappings: dict):
+		self.mappings = mappings
+		return
+
+	def __call__(self, fn: callable):
+		@wraps(fn)
+		def wrapper(*args, **kwargs):
+			validator = Validator(IsObject(IsMappingOf(self.mappings)))
+			bound = signature(fn).bind(*args, **kwargs)
+			bound.apply_defaults()
+			bound.arguments = validator(dict(bound.arguments))
+			return fn(*bound.args, **bound.kwargs)
+		return wrapper