DefStream 0.1.2__py3-none-any.whl

DefStream/Inspector/Inspector.py

@@ -0,0 +1,216 @@
+from logging import getLogger
+from socketserver import ThreadingMixIn
+from threading import Thread
+from typing import (
+	Callable,
+	Dict,
+	Iterable,
+	Optional,
+	Sequence,
+	TYPE_CHECKING,
+	Tuple,
+)
+from wsgiref.simple_server import (
+	WSGIRequestHandler,
+	WSGIServer,
+	make_server,
+)
+
+from .Extension import Extension
+from .Response import Response
+
+if TYPE_CHECKING:
+	from ..Worker.Worker import Worker
+
+__all__ = (
+	'Inspector',
+)
+
+logger = getLogger(__name__)
+
+
+class Server(
+	ThreadingMixIn,
+	WSGIServer,
+):
+	daemon_threads = True
+	block_on_close = False
+
+	def get_request(self):
+		connection, address = super().get_request()
+		connection.settimeout(5)
+		return connection, address
+
+
+class RequestHandler(WSGIRequestHandler):
+	def log_message(
+		self,
+		format: str,
+		*args,
+	) -> None:
+		logger.info(
+			'%s - %s',
+			self.client_address[0],
+			format % args,
+		)
+
+
+class Inspector:
+	def __init__(
+		self,
+		host: str = '127.0.0.1',
+		port: int = 9999,
+		exts: Sequence[Extension] = (),
+	):
+		if isinstance(
+			port,
+			bool,
+		) or not isinstance(
+			port,
+			int,
+		) or not 0 <= port <= 65535:
+			raise ValueError('Inspector port must be between 0 and 65535')
+		self.host = host
+		self.port = port
+		self.exts: Dict[str, Extension] = {}
+		for ext in exts:
+			if not isinstance(
+				ext,
+				Extension,
+			):
+				raise TypeError('Inspector extensions must inherit Extension')
+			if ext.path in self.exts:
+				raise ValueError('Duplicate Inspector path: ' + ext.path)
+			self.exts[ext.path] = ext
+		self.worker: Optional['Worker'] = None
+		self.server: Optional[WSGIServer] = None
+		self.thread: Optional[Thread] = None
+
+	def start(
+		self,
+		worker: 'Worker',
+	) -> None:
+		if self.worker is not None:
+			raise RuntimeError('Inspector can only be attached and started once')
+		self.worker = worker
+		for ext in self.exts.values():
+			ext.start(self)
+		server = make_server(
+			self.host,
+			self.port,
+			self,
+			server_class=Server,
+			handler_class=RequestHandler,
+		)
+		self.server = server
+		thread = Thread(
+			target=self.serve,
+			daemon=True,
+		)
+		self.thread = thread
+		try:
+			thread.start()
+		except BaseException:
+			server.server_close()
+			raise
+
+	def serve(self) -> None:
+		server = self.server
+		if server is None:
+			raise RuntimeError('Inspector server is not initialized')
+		try:
+			server.serve_forever(poll_interval=0.1)
+		except Exception:
+			logger.exception('Inspector HTTP server failed')
+			if self.worker is not None:
+				self.worker.stop()
+			raise
+
+	def stop(self) -> None:
+		server = self.server
+		thread = self.thread
+		if server is not None:
+			try:
+				if thread is not None and thread.is_alive():
+					server.shutdown()
+					thread.join()
+			finally:
+				server.server_close()
+
+	def begin(
+		self,
+		task: str,
+	) -> Tuple[Tuple[Extension, object], ...]:
+		return tuple(
+			(
+				ext,
+				ext.begin(task),
+			)
+			for ext in self.exts.values()
+		)
+
+	def end(
+		self,
+		task: str,
+		contexts: Tuple[Tuple[Extension, object], ...],
+		success: Optional[bool],
+	) -> None:
+		for ext, context in contexts:
+			ext.end(
+				task,
+				context,
+				success,
+			)
+
+	def __call__(
+		self,
+		environ: dict,
+		start_response: Callable,
+	) -> Iterable[bytes]:
+		method = environ['REQUEST_METHOD']
+		environ['wsgi.multithread'] = True
+		headers = []
+		ext = self.exts.get(environ['PATH_INFO'])
+		methods = ext.methods if ext is not None else (
+			'GET',
+			'HEAD',
+		)
+		if method not in methods:
+			response = Response(
+				'405 Method Not Allowed',
+				b'Method not allowed\n',
+				'text/plain; charset=utf-8',
+			)
+			headers.append((
+				'Allow',
+				', '.join(methods),
+			))
+		else:
+			response = ext.handle(
+				self,
+				environ,
+			) if ext is not None else Response(
+				'404 Not Found',
+				b'Not found\n',
+				'text/plain; charset=utf-8',
+			)
+		headers.extend(response.headers)
+		headers.extend((
+			(
+				'Content-Type',
+				response.content_type,
+			),
+			(
+				'Content-Length',
+				str(len(response.body)),
+			),
+			(
+				'Cache-Control',
+				'no-store',
+			),
+		))
+		start_response(
+			response.status,
+			headers,
+		)
+		return [b'' if method == 'HEAD' else response.body]

DefStream/Inspector/Response.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+from typing import Tuple
+
+__all__ = (
+	'Response',
+)
+
+
+@dataclass
+class Response:
+	status: str
+	body: bytes
+	content_type: str
+	headers: Tuple[Tuple[str, str], ...] = ()

DefStream/Inspector/__init__.py

@@ -0,0 +1,9 @@
+from .Inspector import Inspector
+from .Extension import Extension
+from .Response import Response
+
+__all__ = (
+	'Inspector',
+	'Extension',
+	'Response',
+)

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

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

DefStream/Validator/Patterns/Common.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+
+from ..Pattern import Pattern
+
+from operator import eq
+
+__all__ = (
+	'SetDefault',
+	'IsToNone',
+	'IsNotToNone',
+	'IsNotEmpty',
+)
+
+
+class SetDefault(Pattern):
+	def __init__(self, default):
+		self.default = default
+		return
+
+	def __call__(self, parameter):
+		if parameter == None:
+			return self.default
+		return parameter
+
+	def __repr__(self):
+		return '{}({})'.format(
+			self.__class__.__name__,
+			self.default
+		)
+	
+
+class IsToNone(Pattern):
+	def __init__(self, *args):
+		self.patterns = args
+		return
+
+	def __call__(self, parameter):
+		if parameter is None:
+			return 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 IsNotToNone(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if parameter is None:
+			if self.error:
+				raise self.error
+			raise ValueError('{} is None'.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 IsNotEmpty(Pattern):
+	def __init__(self, *args, error=None):
+		self.patterns = args
+		self.error = error
+		return
+
+	def __call__(self, parameter):
+		if eq(len(parameter), 0):
+			if self.error:
+				raise self.error
+			raise ValueError('{} must be not empty'.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])
+		)
+

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

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