DefStream 0.1.2__py3-none-any.whl

DefStream/Broker/Configuration.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+from abc import (
+	ABCMeta,
+	abstractmethod,
+)
+
+__all__ = (
+	'Configuration'
+)
+
+
+class Configuration(metaclass=ABCMeta):
+	"""Configuration Interface for Event Broker"""
+	@abstractmethod
+	def __init__(self, *args, **kwargs):
+		raise NotImplementedError('{} must be implemented __init__'.format(self.__class__.__name__))
+

DefStream/Broker/Connection.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+
+from abc import abstractmethod
+from typing import (
+	Any,
+	Optional,
+	Protocol,
+	runtime_checkable,
+)
+
+from .Consumer import Consumer
+from .Event import EventHandler
+from .Protocol import Sendable
+
+__all__ = (
+	'Connection',
+	'GetExchange',
+	'GetQueue',
+	'GetStream',
+	'GetConsumer',
+	'Declarable',
+	'TaskSender',
+	'Requestable',
+)
+
+
+class Connection(Protocol):
+	@abstractmethod
+	def connect(self) -> None: ...
+
+	@abstractmethod
+	def close(self) -> None: ...
+
+
+class GetExchange(Protocol):
+	@abstractmethod
+	def exchange(
+		self,
+		name: str,
+		/,
+	) -> Sendable: ...
+
+
+class GetQueue(Protocol):
+	@abstractmethod
+	def queue(
+		self,
+		name: str,
+		/,
+	) -> Sendable: ...
+
+
+class GetStream(Protocol):
+	@abstractmethod
+	def stream(
+		self,
+		name: str,
+		/,
+	) -> Sendable: ...
+
+
+class GetConsumer(Protocol):
+	@abstractmethod
+	def consumer(
+		self,
+		handler: Optional[EventHandler] = None,
+	) -> Consumer: ...
+
+
+@runtime_checkable
+class Declarable(Protocol):
+	@abstractmethod
+	def declare(
+		self,
+		parameters: Any,
+	) -> None: ...
+
+
+@runtime_checkable
+class TaskSender(Protocol):
+	@abstractmethod
+	def send(
+		self,
+		body: Any,
+		parameters: Any,
+	) -> Any: ...
+
+
+@runtime_checkable
+class Requestable(Protocol):
+	@abstractmethod
+	def request(
+		self,
+		body: Any,
+		parameters: Any,
+		timeout: float = 5,
+	) -> Any: ...

DefStream/Broker/Consumer.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+from abc import (
+	ABCMeta,
+	abstractmethod,
+)
+from typing import (
+	Any,
+	Callable,
+	Optional,
+)
+
+from .Event import (
+	Event,
+	EventHandler,
+	EventError,
+)
+
+__all__ = (
+	'Consumer'
+)
+
+
+class Consumer(metaclass=ABCMeta):
+	"""Consumer Interface of Event Broker"""
+	def complete(
+		self,
+		event: Event,
+		result: Any,
+	) -> None:
+		event.ack()
+
+	def call(self, callback: Callable[[], None]) -> None:
+		"""Schedule a callback on the connection owner thread."""
+		raise NotImplementedError('Consumer must implement thread-safe callback scheduling')
+
+	def fail(
+		self,
+		event: Event,
+		policy: Optional[EventError] = None,
+	) -> None:
+		raise NotImplementedError('Consumer must implement failure policies')
+
+	def close(self) -> None:
+		raise NotImplementedError('Consumer must implement close')
+
+	@abstractmethod
+	def subs(
+		self,
+		queue: Any,
+		handler: Optional[EventHandler] = None,
+	) -> None:
+		raise NotImplementedError('{} must implement subs'.format(self.__class__.__name__))
+	@abstractmethod
+	def run(self):
+		raise NotImplementedError('{} must be implemented run'.format(self.__class__.__name__))
+	@abstractmethod
+	def stop(self):
+		raise NotImplementedError('{} must be implemented stop'.format(self.__class__.__name__))

DefStream/Broker/Errors.py

@@ -0,0 +1,14 @@
+__all__ = (
+	'RemoteError',
+)
+
+
+class RemoteError(RuntimeError):
+	def __init__(
+		self,
+		code: str,
+		message: str,
+	):
+		self.code = code
+		self.message = message
+		super().__init__(f'{code}: {message}')

DefStream/Broker/Event.py

@@ -0,0 +1,35 @@
+from abc import abstractmethod
+from typing import (
+	Any,
+	Protocol,
+)
+
+__all__ = (
+	'Event',
+	'EventHandler',
+	'EventError',
+)
+
+
+class Event(Protocol):
+	@property
+	def body(self) -> Any: ...
+
+	def ack(self) -> None: ...
+	def nack(self) -> None: ...
+	def reject(self) -> None: ...
+
+
+class EventHandler(Protocol):
+	@abstractmethod
+	def __call__(
+		self,
+		event: Event,
+	) -> None: ...
+
+
+class EventError(Protocol):
+	def __call__(
+		self,
+		event: Event,
+	) -> None: ...

DefStream/Broker/Implements/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

DefStream/Broker/Policies.py

@@ -0,0 +1,25 @@
+from .Event import (
+	Event,
+	EventError,
+)
+
+__all__ = (
+	'Requeue',
+	'Reject',
+)
+
+
+class Requeue(EventError):
+	def __call__(
+		self,
+		event: Event,
+	) -> None:
+		event.nack()
+
+
+class Reject(EventError):
+	def __call__(
+		self,
+		event: Event,
+	) -> None:
+		event.reject()

DefStream/Broker/Protocol.py

@@ -0,0 +1,45 @@
+from typing import (
+	Any,
+	Iterable,
+	Optional,
+	Protocol,
+)
+
+from .Event import Event
+
+__all__ = (
+	'Sendable',
+	'Callable',
+	'Poppable',
+	'Readable',
+)
+
+
+class Sendable(Protocol):
+	def send(
+		self,
+		body: Any,
+	) -> Any: ...
+
+
+class Callable(Protocol):
+	def call(
+		self,
+		body: Any,
+		timeout: float = 5,
+	) -> Any: ...
+
+
+class Poppable(Protocol):
+	def pop(
+		self,
+		timeout: Optional[int] = None,
+	) -> Optional[Event]: ...
+
+
+class Readable(Protocol):
+	def read(
+		self,
+		offset: int = 0,
+		timeout: Optional[int] = None,
+	) -> Iterable[Event]: ...

DefStream/Broker/__init__.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+from .Configuration import Configuration
+from .Connection import (
+	Connection,
+	GetExchange,
+	GetQueue,
+	GetStream,
+	GetConsumer,
+	Declarable,
+	TaskSender,
+	Requestable,
+)
+from .Protocol import (
+	Sendable,
+	Callable,
+	Poppable,
+	Readable,
+)
+from .Errors import RemoteError
+from .Consumer import Consumer
+from .Event import (
+	Event,
+	EventHandler,
+	EventError,
+)
+
+__all__ = (
+	'Configuration',
+	'Connection',
+	'GetExchange',
+	'GetQueue',
+	'GetStream',
+	'GetConsumer',
+	'Declarable',
+	'TaskSender',
+	'Requestable',
+	'Sendable',
+	'Callable',
+	'RemoteError',
+	'Poppable',
+	'Readable',
+	'Consumer',
+	'EventHandler',
+	'Event',
+	'EventError',
+)