DefStream 0.1.24__110-py3-none-any.whl

DefStream/Validator/Patterns/Object.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+from ..Validator import Validator
+
+from collections.abc import Mapping
+
+from typing import (
+	Dict,
+	Mapping as TypingMapping,
+	Optional,
+	Sequence,
+	Union,
+)
+
+__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: TypingMapping[str, Union[Validator, Pattern, Sequence[Pattern]]] = {},
+		error: Optional[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: TypingMapping[str, Union[Validator, Pattern, Sequence[Pattern]]],
+	) -> Dict[str, Validator]:
+		mapped: Dict[str, Validator] = {}
+		for key, value in mappings.items():
+			if isinstance(value, Sequence):
+				mapped[key] = Validator(*value)
+				continue
+			if isinstance(value, Pattern):
+				mapped[key] = Validator(value)
+				continue
+			if isinstance(value, Validator):
+				mapped[key] = value
+				continue
+			raise ValueError('Invalid mapping table, {} must be dictionary or listable of Patterns, or callable based Pattern'.format(value))
+		return mapped
+
+	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]
+			)
+		)

DefStream/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
+		)

DefStream/Validator/Patterns/String.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from operator import eq
+from typing import Optional
+
+__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: Optional[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

DefStream/Validator/Patterns/Type.py

@@ -0,0 +1,355 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+from ast import literal_eval
+from collections.abc import (
+	Iterable,
+	Mapping,
+)
+from builtins import type as type_of
+from typing import (
+	Optional,
+	Sequence,
+	Type,
+	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: Optional[BaseException] = None,
+	):
+		self.type = type if isinstance(type, type_of) else tuple(type)
+		self.patterns = patterns if isinstance(patterns, Iterable) else (patterns,)
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if isinstance(self.type, tuple):
+			matches = isinstance(parameter, self.type)
+		else:
+			matches = type(parameter) is self.type
+		if not matches:
+			if self.error:
+				raise self.error
+			expected = ', '.join(
+				item.__name__
+				for item in self.type
+			) if isinstance(self.type, tuple) else self.type.__name__
+			raise TypeError('{} must be {}'.format(
+				'\'{}\''.format(parameter) if isinstance(parameter, str) else parameter,
+				expected,
+			))
+		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 IsBool(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(bool, patterns=args, error=error)
+		return
+
+
+class IsInteger(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(int, patterns=args, error=error)
+		return
+
+
+class IsFloat(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(float, patterns=args, error=error)
+		return
+
+
+class IsNumber(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__((int, float), patterns=args, error=error)
+		return
+
+
+class IsString(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(str, patterns=args, error=error)
+		return
+
+
+class IsList(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(list, patterns=args, error=error)
+		return
+
+
+class IsTuple(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(tuple, patterns=args, error=error)
+		return
+
+
+class IsSet(IsTypeOf):
+	def __init__(self, *args, error: Optional[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: Optional[BaseException] = None):
+		super().__init__(dict, patterns=args, error=error)
+		return
+
+
+class IsByteString(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(bytes, patterns=args, error=error)
+		return
+
+
+class IsByteArray(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(bytearray, patterns=args, error=error)
+		return
+	
+
+class IsDecimal(IsTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		from decimal import Decimal
+		super().__init__(Decimal, patterns=args, error=error)
+		return
+
+
+class IsDataObject(Pattern):
+	def __init__(
+		self, 
+		*patterns: Pattern,
+		error: Optional[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: Optional[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: Optional[BaseException] = None):
+		super().__init__(bool, patterns=args, error=error, eval=True)
+		return
+
+
+class ToInteger(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(int, patterns=args, error=error, eval=True)
+		return
+
+
+class ToFloat(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(float, patterns=args, error=error, eval=True)
+		return
+
+
+class ToString(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(str, patterns=args, error=error)
+		return
+
+
+class ToList(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(list, patterns=args, error=error)
+		return
+
+
+class ToTuple(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(tuple, patterns=args, error=error)
+		return
+	
+
+class ToSet(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(set, patterns=args, error=error)
+		return
+
+
+class ToObject(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(dict, patterns=args, error=error)
+		return
+
+
+class ToByteString(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(bytes, patterns=args, error=error)
+		return
+
+
+class ToByteArray(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		super().__init__(bytearray, patterns=args, error=error)
+		return
+
+
+class ToDecimal(ToTypeOf):
+	def __init__(self, *args, error: Optional[BaseException] = None):
+		from decimal import Decimal
+		super().__init__(Decimal, patterns=args, error=error)
+		return
+
+
+class ToDataObject(Pattern):
+	def __init__(
+		self, 
+		*patterns: Pattern,
+		error: Optional[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:
+			data_object = 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(data_object.__class__):
+			if self.error:
+				raise self.error
+			raise TypeError('{} must be dataclass'.format(
+				'\'{}\''.format(data_object) if isinstance(data_object, str) else data_object,
+			))
+		for pattern in self.patterns:
+			data_object = pattern(data_object)
+		return data_object