DefEssential 0.1.8__25-py3-none-any.whl

DefEssential/Validator/Patterns/Compare.py

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from operator import eq, ne, gt, ge, lt, le
+
+__all__ = (
+	'IsIn',
+	'IsNotIn',
+	'IsEqualTo',
+	'IsNotEqualTo',
+	'IsGreaterThan',
+	'IsGreaterEqualTo',
+	'IsLessThan',
+	'IsLessEqualTo',
+)
+
+
+class IsIn(Pattern):
+	def __init__(self, *args, error=None):
+		self.compares = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if parameter not in self.compares:
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be in {}'.format(parameter, self.compares))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(c) for c in self.compares]
+			)
+		)
+
+
+class IsNotIn(Pattern):
+	def __init__(self, *args, error=None):
+		self.compares = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if parameter in self.compares:
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be not in {}'.format(parameter, self.compares))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(c) for c in self.compares]
+			)
+		)
+
+
+class IsEqualTo(Pattern):
+	def __init__(self, equal, error=None):
+		self.equal = equal
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not eq(parameter, self.equal):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must equal to {}'.format(parameter, self.equal))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.equal
+		)
+
+
+class IsNotEqualTo(Pattern):
+	def __init__(self, equal, error=None):
+		self.equal = equal
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not ne(parameter, self.equal):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must not equal to {}'.format(parameter, self.equal))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.equal
+		)
+
+
+class IsGreaterEqualTo(Pattern):
+	def __init__(self, compare, error=None):
+		self.compare = compare
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not ge(parameter, self.compare):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be greater equal to {}'.format(parameter, self.compare))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.compare
+		)
+
+
+class IsGreaterThan(Pattern):
+	def __init__(self, compare, error=None):
+		self.compare = compare
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not gt(parameter, self.compare):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be greater than {}'.format(parameter, self.compare))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.compare
+		)
+
+
+class IsLessEqualTo(Pattern):
+	def __init__(self, compare, error=None):
+		self.compare = compare
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not le(parameter, self.compare):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be less equal to {}'.format(parameter, self.compare))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.compare
+		)
+
+
+class IsLessThan(Pattern):
+	def __init__(self, compare, error=None):
+		self.compare = compare
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not lt(parameter, self.compare):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be less than {}'.format(parameter, self.compare))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.compare
+		)

DefEssential/Validator/Patterns/Condition.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+__all__ = (
+	'All',
+	'Any',
+)
+
+
+class All(Pattern):
+	def __init__(self, *args, error=None) -> None:
+		self.patterns = args
+		self.error = error
+		return
+	
+	def __call__(self, parameter):
+		try:
+			for pattern in self.patterns:
+				parameter = pattern(parameter)
+			return parameter
+		except Exception as e:
+			if self.error:
+				raise self.error
+			raise e
+		
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[p.__repr__() for p in self.patterns]
+			)
+		)
+
+
+class Any(Pattern):
+	def __init__(self, *args, error=None) -> None:
+		self.patterns = args
+		self.error = error
+		return
+	
+	def __call__(self, parameter):
+		for pattern in self.patterns:
+			try:
+				parameter = pattern(parameter)
+				return parameter
+			except Exception:
+				pass
+		if self.error:
+			raise self.error
+		raise ValueError('{} must be validated in {}'.format(
+			parameter,
+			', '.join([p.__repr__() for p in self.patterns])
+		))
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join([p.__repr__() for p in self.patterns])
+		)

DefEssential/Validator/Patterns/DataObject.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+from ..Validator import Validator
+
+from dataclasses import is_dataclass
+
+from typing import Dict, Union, Sequence
+
+__all__ = (
+	'IsRequiredIn',
+	'IsMappingOf',
+)
+
+
+class IsRequiredIn(Pattern):
+	def __init__(self, *args, error=None):
+		self.args = args
+		self.error = error
+		return
+
+	def __call__(self, parameter: object) -> object:
+		if not is_dataclass(parameter.__class__):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be dataclass'.format(parameter))
+		for arg in self.args:
+			if not hasattr(parameter, arg):
+				if self.error:
+					raise self.error
+				raise ValueError('{} is required in {}'.format(arg, parameter))
+		return parameter
+
+	def __repr__(self) -> str:
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(p) for p in self.args]
+			)
+		)
+
+
+class IsMappingOf(Pattern):
+	def __init__(
+		self, 
+		mappings: Dict[str, Union[Validator, Pattern, Sequence[Pattern]]] = {}, 
+		error: BaseException = None
+	):
+		self.mappings = self.__mapper__(mappings)
+		self.error = error
+		return
+
+	def __call__(self, parameter: object) -> object:
+		if not is_dataclass(parameter.__class__):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be dataclass'.format(parameter))
+		if self.mappings:
+			for key, validator in self.mappings.items():
+				setattr(parameter, key, validator(getattr(parameter, key) if hasattr(parameter, key) else None))
+		return parameter
+
+	def __mapper__(self, mappings: Dict[str, Validator]) -> Dict[str, Validator]:
+		if not isinstance(mappings, dict):
+			raise TypeError('{} must be dict'.format(mappings))
+		for key, value in mappings.items():
+			if isinstance(value, Sequence):
+				mappings[key] = Validator(*value)
+				continue
+			if isinstance(value, Pattern):
+				mappings[key] = Validator(value)
+				continue
+			if isinstance(value, Validator):
+				mappings[key] = value
+				continue
+			raise ValueError('Invalid mapping table, {} must be dictionary or listable of Patterns, or callable based Pattern'.format(value))
+		return mappings
+
+	def __repr__(self) -> str:
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				['{}: {}'.format(k, repr(v)) for k, v in self.mappings.items()]
+			)
+		)

DefEssential/Validator/Patterns/DateTime.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from datetime import datetime, date, time
+
+__all__ = (
+	'IsDateTime',
+	'IsDate',
+	'IsTime',
+	'ToDateTime',
+	'ToDate',
+	'ToTime',
+)
+
+
+class IsDateTime(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not isinstance(parameter, datetime):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be datetime'.format(parameter))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter
+
+
+class IsDate(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not isinstance(parameter, date):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be date'.format(parameter))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter
+
+
+class IsTime(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if not isinstance(parameter, time):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be time'.format(parameter))
+		for pattern in self.patterns:
+			parameter = pattern(parameter)
+		return parameter
+
+
+class ToDateTime(Pattern):
+	def __init__(self, isoformat=True, error=None):
+		self.isoformat = isoformat
+		self.error = error
+		return
+	def __call__(self, parameter):
+		try:
+			if self.isoformat:
+				return datetime.fromisoformat(parameter)
+			return datetime.strptime(parameter, '%Y-%m-%d %H:%M:%S')
+		except:
+			if self.error:
+				raise self.error
+			raise ValueError('{} is not datetime'.format(parameter))
+
+
+class ToDate(Pattern):
+	def __init__(self, isoformat=True, error=None):
+		self.isoformat = isoformat
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		try:
+			if self.isoformat:
+				return date.fromisoformat(parameter)
+			return datetime.strptime(parameter, '%Y-%m-%d').date()
+		except:
+			if self.error:
+				raise self.error
+			raise ValueError('{} is not date'.format(parameter))
+
+
+class ToTime(Pattern):
+	def __init__(self, isoformat=True, error=None):
+		self.isoformat = isoformat
+		self.error = error
+		return
+	def __call__(self, parameter):
+		try:
+			if self.isoformat:
+				return time.fromisoformat(parameter)
+			return datetime.strptime(parameter, '%H:%M:%S').time()
+		except:
+			if self.error:
+				raise self.error
+			raise ValueError('{} is not time'.format(parameter))

DefEssential/Validator/Patterns/Number.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+__all__ = (
+	'IsRange',
+)
+
+
+class IsRange(Pattern):
+	def __init__(self, start, stop=None, step=None, error=None):
+		self.range = [start]
+		if stop:
+			self.range.append(stop)
+		if step:
+			self.range.append(step)
+		self.start = start
+		self.stop = stop
+		self.step = step
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if parameter not in [v for v in range(*self.range)]:
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be in the range {}'.format(
+				parameter,
+				'between {} to {}{}'.format(
+					self.start if self.stop else 0,
+					self.stop if self.stop else self.start,
+					', in increments of {}'.format(self.step) if self.step else ''
+				),
+			))
+		return parameter
+
+	def __repr__(self):
+		return '{}(start={}, stop={}, step={})'.format(
+			self.__class__.__name__,
+			self.start,
+			self.stop,
+			self.step,
+		)

DefEssential/Validator/Patterns/Object.py

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+from ..Validator import Validator
+
+from collections.abc import Mapping
+
+from typing import Dict, Union, Sequence
+
+__all__ = (
+	'IsRequiredIn',
+	'IsMappingOf',
+	'IsKeyOf',
+	'IsValueOf',
+)
+
+
+class IsRequiredIn(Pattern):
+	def __init__(self, *args, error=None):
+		self.args = args
+		self.error = error
+		return
+
+	def __call__(self, parameter: Dict) -> Dict:
+		if not isinstance(parameter, Mapping):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be dict'.format(parameter))
+		keys = parameter.keys()
+		for arg in self.args:
+			if arg not in keys:
+				if self.error:
+					raise self.error
+				raise ValueError('{} is required in {}'.format(arg, parameter))
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(p) for p in self.args]
+			)
+		)
+
+
+class IsMappingOf(Pattern):
+	def __init__(
+		self, 
+		mappings: Dict[str, Union[Validator, Pattern, Sequence[Pattern]]] = {}, 
+		error: BaseException = None
+	):
+		self.mappings = self.__mapper__(mappings)
+		self.error = error
+		return
+
+	def __call__(self, parameter: Dict) -> Dict:
+		if not isinstance(parameter, Mapping):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be dict'.format(parameter))
+		if self.mappings:
+			for key, validator in self.mappings.items():
+				parameter[key] = validator(parameter[key] if key in parameter.keys() else None)
+		return parameter
+
+	def __mapper__(self, mappings: Dict[str, Validator]) -> Dict[str, Validator]:
+		if not isinstance(mappings, dict):
+			raise TypeError('{} must be dict'.format(mappings))
+		for key, value in mappings.items():
+			if isinstance(value, Sequence):
+				mappings[key] = Validator(*value)
+				continue
+			if isinstance(value, Pattern):
+				mappings[key] = Validator(value)
+				continue
+			if isinstance(value, Validator):
+				mappings[key] = value
+				continue
+			raise ValueError('Invalid mapping table, {} must be dictionary or listable of Patterns, or callable based Pattern'.format(value))
+		return mappings
+
+	def __repr__(self) -> str:
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				['{}: {}'.format(k, repr(v)) for k, v in self.mappings.items()]
+			)
+		)
+
+
+class IsKeyOf(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter: Dict) -> Dict:
+		if not isinstance(parameter, Mapping):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be dict'.format(parameter))
+		try:
+			for k, v in parameter.items():
+				for pattern in self.patterns:
+					k = pattern(k)
+				parameter[k] = v
+			return parameter
+		except Exception as e:
+			if self.error:
+				raise self.error
+			raise e
+
+	def __repr__(self) -> str:
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(p) for p in self.patterns]
+			)
+		)
+
+
+class IsValueOf(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter: Dict) -> Dict:
+		if not isinstance(parameter, Mapping):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be dict'.format(parameter))
+		try:
+			for k, v in parameter.items():
+				for pattern in self.patterns:
+					v = pattern(v)
+				parameter[k] = v
+			return parameter
+		except Exception as e:
+			if self.error:
+				raise self.error
+			raise e
+
+	def __repr__(self) -> str:
+		return '{}({})'.format(
+			self.__class__.__name__,
+			', '.join(
+				[repr(p) for p in self.patterns]
+			)
+		)