DefStream-RabbitMQ 0.1.4__9-py3-none-any.whl

DefStream/Broker/Implements/RabbitMQ/Queue.py

@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*-
+
+from DefStream.Broker import (
+	Sendable,
+	Callable,
+	Poppable,
+	RemoteError,
+	validate_priority,
+)
+
+from .Serializer import (
+	Encoder,
+	Decoder,
+)
+from .Event import Event
+from copy import deepcopy
+from math import (
+	ceil,
+	isfinite,
+)
+
+from pika import (
+	BlockingConnection,
+	BasicProperties,
+	ConnectionParameters,
+)
+
+from time import (
+	time,
+	sleep,
+	monotonic,
+)
+from uuid import uuid4
+
+from typing import (
+	Any,
+	Optional,
+	Dict,
+)
+
+__all__ = (
+	'Queue'
+)
+
+
+class Queue(
+	Sendable,
+	Callable,
+	Poppable,
+):
+	"""Queue of Event Broker for RabbitMQ"""
+	def __init__(
+		self,
+		connection: BlockingConnection,
+		encode: Encoder,
+		decode: Decoder,
+		name: str = None,
+		rpc_parameters: Optional[ConnectionParameters] = None,
+	):
+		self.connection = connection
+		self.encode = encode
+		self.decode = decode
+		self.channel = self.connection.channel()
+		self.channel.auto_decode = False
+		self.queue = name
+		self.event = None
+		self.rpc_parameters = rpc_parameters
+		return
+
+	def __del__(self):
+		if self.channel and self.channel.is_open:
+			self.channel.close()
+		return
+	
+	def __str__(self): return self.queue
+
+	def send(
+		self,
+		body,
+		event: str = None,
+		headers: Dict = {},
+		priority: Optional[int] = None,
+		expiration: int = None,
+		timestamp: int = None,
+		persistent: bool = True,
+		id: str = None,
+		reply_to: str = None,
+		correlation_id: str = None,
+	):
+		validate_priority(
+			priority,
+			255,
+		)
+		if not timestamp: timestamp = int(time())
+		if not id: id = uuid4().hex
+		properties = BasicProperties(
+			type=event if event else '',
+			headers=headers,
+			content_type=self.encode.format,
+			content_encoding=self.encode.charset,
+			priority=priority,
+			timestamp=timestamp,
+			expiration=expiration,
+			message_id=id,
+			delivery_mode=2 if persistent else 1,
+			reply_to=reply_to,
+			correlation_id=correlation_id,
+		)
+		self.channel.basic_publish(
+			exchange='',
+			routing_key=self.queue,
+			properties=properties,
+			body=self.encode(body)
+		)
+		return id
+
+	def call(
+		self,
+		body: Any,
+		timeout: float = 5,
+		*,
+		priority: Optional[int] = None,
+	) -> Any:
+		validate_priority(
+			priority,
+			255,
+		)
+		if self.rpc_parameters is None:
+			raise RuntimeError('RPC requires connection parameters; obtain the queue through Connection.queue')
+		if isinstance(
+			timeout,
+			bool,
+		) or not isinstance(
+			timeout,
+			(
+				int,
+				float,
+			),
+		) or not isfinite(timeout) or timeout <= 0:
+			raise ValueError('RPC timeout must be a finite positive number of seconds')
+		deadline = monotonic() + timeout
+		settings = deepcopy(self.rpc_parameters)
+		settings.connection_attempts = 1
+		settings.socket_timeout = min(
+			settings.socket_timeout,
+			timeout,
+		)
+		settings.stack_timeout = timeout
+		settings.blocked_connection_timeout = timeout
+		connection = BlockingConnection(settings)
+		try:
+			channel = connection.channel()
+			reply_queue = channel.queue_declare(
+				queue='',
+				exclusive=True,
+				auto_delete=True,
+			).method.queue
+			channel.confirm_delivery()
+			correlation_id = uuid4().hex
+			responses = []
+
+			def receive(
+				channel,
+				method,
+				properties,
+				payload,
+			):
+				if properties.correlation_id == correlation_id:
+					responses.append((
+						properties,
+						payload,
+					))
+
+			channel.basic_consume(
+				reply_queue,
+				on_message_callback=receive,
+				auto_ack=True,
+			)
+			remaining = deadline - monotonic()
+			if remaining <= 0:
+				raise TimeoutError('RPC timed out before request publication')
+			channel.basic_publish(
+				exchange='',
+				routing_key=self.queue,
+				body=self.encode(body),
+				properties=BasicProperties(
+					priority=priority,
+					reply_to=reply_queue,
+					correlation_id=correlation_id,
+					content_type=self.encode.format,
+					content_encoding=self.encode.charset,
+					expiration=str(max(
+						1,
+						ceil(remaining * 1000),
+					)),
+				),
+				mandatory=True,
+			)
+			while not responses:
+				remaining = deadline - monotonic()
+				if remaining <= 0:
+					raise TimeoutError(f'RPC response timed out for queue {self.queue!r}')
+				connection.process_data_events(time_limit=min(
+					remaining,
+					0.1,
+				))
+			properties, payload = responses[0]
+			response = self.decode(
+				payload,
+				properties.content_type,
+				properties.content_encoding,
+			)
+			if not isinstance(
+				response,
+				dict,
+			) or type(response.get('ok')) is not bool:
+				raise ValueError('Invalid RPC response envelope')
+			if response['ok']:
+				if 'result' not in response:
+					raise ValueError('RPC response has no result')
+				return response['result']
+			error = response.get('error')
+			if not isinstance(
+				error,
+				dict,
+			) or not isinstance(
+				error.get('code'),
+				str,
+			) or not isinstance(
+				error.get('message'),
+				str,
+			):
+				raise ValueError('Invalid RPC error response')
+			raise RemoteError(
+				error['code'],
+				error['message'],
+			)
+		finally:
+			if connection.is_open:
+				connection.close()
+
+	def pop(self, timeout: int = None) -> Optional[Event]:
+		channel = self.channel
+		channel.basic_qos(0, 1, False)
+		deadline = time() + (timeout / 1000) if timeout else None
+		while True:
+			method, properties, body = channel.basic_get(queue=self.queue, auto_ack=False)
+			if method:
+				return Event(
+					channel,
+					self.queue,
+					None,
+					method.delivery_tag,
+					properties,
+					self.decode(body, properties.content_type, properties.content_encoding),
+				)
+			if deadline and time() >= deadline:
+				break
+			sleep(0.1)
+		return

DefStream/Broker/Implements/RabbitMQ/Serializer.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+from abc import (
+	ABCMeta,
+	abstractmethod,
+)
+
+from json import (
+	dumps,
+	loads,
+)
+from typing import Any
+
+__all__ = (
+	'Encoder',
+	'Decoder',
+	'JavaScriptObjectNotationEncoder',
+	'JavaScriptObjectNotationDecoder',
+)
+
+class Encoder(metaclass=ABCMeta):
+	"""Encoder Interface"""
+	@abstractmethod
+	def __call__(self, obj: Any) -> bytes:
+		raise NotImplementedError('{} must be implemented __call__'.format(self.__class__.__name__))
+
+	@property
+	@abstractmethod
+	def format(self) -> str:
+		raise NotImplementedError('{} must be implemented format'.format(self.__class__.__name__))	
+
+	@property
+	@abstractmethod
+	def charset(self) -> str:
+		raise NotImplementedError('{} must be implemented charset'.format(self.__class__.__name__))
+	
+
+class Decoder(metaclass=ABCMeta):
+	"""Decoder Interface"""
+	@abstractmethod
+	def __call__(self, obj: bytes, format: str, charset: str) -> Any:
+		raise NotImplementedError('{} must be implemented __call__'.format(self.__class__.__name__))
+
+
+class JavaScriptObjectNotationEncoder(Encoder):
+	"""JavaScriptObjectNotation Encoder"""
+	def __call__(self, obj: Any) -> bytes:
+		return dumps(obj, ensure_ascii=False).encode(self.charset)
+
+	@property
+	def format(self) -> str: return 'application/json'
+
+	@property
+	def charset(self) -> str: return 'utf-8'
+
+
+class JavaScriptObjectNotationDecoder(Decoder):
+	"""JavaScriptObjectNotation Decoder"""
+	def __call__(self, obj: bytes, format: str, charset: str) -> Any:
+		if format != 'application/json': raise ValueError('format is not support')
+		return loads(obj.decode(charset))

DefStream/Broker/Implements/RabbitMQ/Stream.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+
+from DefStream.Broker import (
+	Sendable,
+	Readable,
+)
+from .Serializer import (
+	Encoder,
+	Decoder,
+)
+from .Event import Event
+
+from pika import (
+	BlockingConnection,
+	BasicProperties,
+)
+
+from time import time
+from uuid import uuid4
+
+from typing import (
+	Dict,
+	Iterable,
+)
+
+__all__ = (
+	'Queue'
+)
+
+
+class Stream(
+	Sendable,
+	Readable,
+):
+	"""Stream of Event Broker for RabbitMQ"""
+	def __init__(
+		self,
+		connection: BlockingConnection,
+		encode: Encoder,
+		decode: Decoder,
+		name: str = None,
+	):
+		self.connection = connection
+		self.encode = encode
+		self.decode = decode
+		self.channel = self.connection.channel()
+		self.channel.auto_decode = False
+		self.queue = name
+		self.event = None
+		return
+
+	def __del__(self):
+		if self.channel and self.channel.is_open:
+			self.channel.close()
+		return
+	
+	def __str__(self): return self.queue
+
+	def send(
+		self,
+		body,
+		event: str = None,
+		headers: Dict = {},
+		timestamp: int = None,
+		id: str = None,
+	):
+		if not timestamp: timestamp = int(time())
+		if not id: id = uuid4().hex
+		properties = BasicProperties(
+			type=event if event else '',
+			headers=headers,
+			content_type=self.encode.format,
+			content_encoding=self.encode.charset,
+			timestamp=timestamp,
+			message_id=id,
+		)
+		self.channel.basic_publish(
+			exchange='',
+			routing_key=self.queue,
+			properties=properties,
+			body=self.encode(body)
+		)
+		return id
+
+	def read(self, offset: int = 0, timeout: int = None) -> Iterable[Event]:
+		channel = self.channel
+		channel.basic_qos(0, 1, False)
+
+		deadline = time() + (timeout / 1000) if timeout else None
+
+		try:
+			for method, properties, body in channel.consume(
+				queue=self.queue,
+				auto_ack=False,
+				inactivity_timeout=1,
+				arguments={'x-stream-offset': offset},
+			):
+				if method is None:
+					if deadline and time() >= deadline:
+						break
+					continue
+
+				event = Event(
+					channel,
+					self.queue,
+					method.consumer_tag,
+					method.delivery_tag,
+					properties,
+					self.decode(body, properties.content_type, properties.content_encoding),
+				)
+
+				try:
+					yield event
+					channel.basic_ack(delivery_tag=method.delivery_tag)
+				except Exception:
+					channel.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
+					raise
+		finally:
+			channel.cancel()

DefStream/Broker/Implements/RabbitMQ/Subscription.py

@@ -0,0 +1,74 @@
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import (
+	Any,
+	Optional,
+)
+from DefStream.Broker import validate_priority
+
+__all__ = (
+	'Subscription',
+)
+
+
+@dataclass(frozen=True)
+class Subscription:
+	queue: str
+	offset: Optional[int] = None
+	qos: Optional[int] = None
+	error: Optional[str] = None
+	max_priority: Optional[int] = None
+	priority: Optional[int] = None
+
+	def __post_init__(self):
+		if self.priority is not None and self.max_priority is None:
+			object.__setattr__(
+				self,
+				'max_priority',
+				255,
+			)
+		validate_priority(
+			self.max_priority,
+			255,
+			minimum=1,
+			name='max_priority',
+		)
+		self.validate_priority(self.priority)
+		if not isinstance(self.queue, str) or not self.queue:
+			raise ValueError('Subscription queue must be a non-empty string')
+		if self.error is not None:
+			if not isinstance(
+				self.error,
+				str,
+			) or not self.error:
+				raise ValueError('Subscription error must be a non-empty string or None')
+		if self.offset is not None and (isinstance(self.offset, bool) or not isinstance(self.offset, int)):
+			raise ValueError('Subscription offset must be an integer')
+		if self.qos is not None:
+			if isinstance(
+				self.qos,
+				bool,
+			) or not isinstance(
+				self.qos,
+				int,
+			) or not 0 <= self.qos <= 65535:
+				raise ValueError('Subscription qos must be an integer between 0 and 65535')
+		return
+
+	def validate_priority(
+		self,
+		priority: Optional[int],
+	) -> None:
+		validate_priority(
+			priority,
+			255 if self.max_priority is None else self.max_priority,
+		)
+		return
+
+	@classmethod
+	def parse(cls, parameters: Any) -> 'Subscription':
+		if isinstance(parameters, cls):
+			return parameters
+		if isinstance(parameters, Mapping):
+			return cls(**dict(parameters))
+		raise TypeError('RabbitMQ subscriptions require a Subscription or mapping')

DefStream/Broker/Implements/RabbitMQ/__init__.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+from .Configuration import Configuration
+from .Connection import (
+	Connection,
+	ExchangeType,
+	Parameters,
+	All,
+	Any,
+)
+from .Exchange import Exchange
+from .Queue import Queue
+from .Stream import Stream
+from .Consumer import Consumer
+from .Subscription import Subscription
+from .Policies import (
+	Requeue,
+	Reject,
+)
+from .Event import (
+	Event,
+	EventHandler,
+)
+from .Serializer import (
+	Encoder,
+	Decoder,
+)
+
+__all__ = (
+	'Configuration',
+	'Connection',
+	'ExchangeType',
+	'Parameters',
+	'All',
+	'Any',
+	'Exchange',
+	'Queue',
+	'Stream',
+	'Consumer',
+	'Subscription',
+	'Requeue',
+	'Reject',
+	'Event',
+	'EventHandler',
+	'Encoder',
+	'Decoder',
+)