DefStream 0.1.2__py3-none-any.whl

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

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

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

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

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,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