DefStream 0.1.18__74-py3-none-any.whl

DefStream/Worker/Worker.py

@@ -0,0 +1,421 @@
+from abc import (
+	ABC,
+	abstractmethod,
+)
+from collections.abc import Mapping
+from logging import getLogger
+from threading import Event as PyEvent
+from typing import (
+	Any,
+	List,
+	Callable,
+	Optional,
+	Sequence,
+	Type,
+	Tuple,
+	Union,
+)
+
+from ..Broker import (
+	Connection,
+	GetConsumer,
+	Consumer,
+	EventHandler,
+)
+from ..Broker.Event import Event
+from .Message import task_parameters
+from ..Inspector import Inspector
+from .Pool import (
+	Pool,
+	PoolFull,
+)
+from .Run import Run
+from .Executor import run_cleanups
+from .Startup import startup
+
+__all__ = (
+	'Worker',
+	'WorkerSetup',
+	'WorkerCleanup',
+)
+
+class WorkerSetup(ABC):
+	@abstractmethod
+	def __call__(
+		self,
+		worker: 'Worker',
+	) -> None:
+		raise NotImplementedError
+
+
+class WorkerCleanup(ABC):
+	@abstractmethod
+	def __call__(
+		self,
+		worker: 'Worker',
+	) -> None:
+		raise NotImplementedError
+
+
+def worker_hooks(
+	hooks: Optional[Union[Callable[['Worker'], None], Sequence[Callable[['Worker'], None]]]],
+) -> Tuple[Callable[['Worker'], None], ...]:
+	result = () if hooks is None else tuple(hooks) if isinstance(
+		hooks,
+		Sequence,
+	) else (hooks,)
+	if not all(callable(hook) for hook in result):
+		raise TypeError('Worker hooks must be callable')
+	return result
+
+
+class Worker:
+	logger = getLogger('DefStream.Worker')
+
+	def __init__(
+		self,
+		broker: Connection,
+		pool: Pool,
+		setups: Optional[Union[WorkerSetup, Sequence[WorkerSetup]]] = None,
+		cleanups: Optional[Union[WorkerCleanup, Sequence[WorkerCleanup]]] = None,
+		inspector: Optional[Inspector] = None,
+	):
+		self.broker = broker
+		self.pool = pool
+		self.tasks: List[Type[Run]] = []
+		self.consumer: Optional[Consumer] = None
+		self.started = False
+		self.running = PyEvent()
+		self.stopping = PyEvent()
+		self.finished = PyEvent()
+		self.pending = 0
+		self.setups = worker_hooks(setups)
+		self.cleanups = worker_hooks(cleanups)
+		self.inspector = inspector
+
+	def add(
+		self,
+		run: Type[Run],
+	) -> None:
+		if self.started:
+			raise RuntimeError('Cannot register runs after starting the worker')
+		task_parameters(run)
+		if run in self.tasks:
+			raise ValueError('Run is already registered')
+		if any(
+			registered.name == run.name
+			for registered in self.tasks
+		):
+			raise ValueError('Duplicate Run name: ' + run.name)
+		self.tasks.append(run)
+		self.logger.debug(
+			'Task registered: task=%s.%s',
+			run.__module__,
+			run.__qualname__,
+		)
+
+	def run(self) -> None:
+		if self.started:
+			raise RuntimeError('Worker can only be started once')
+		if not self.tasks:
+			raise RuntimeError('Register at least one Run before starting')
+		self.started = True
+		self.logger.info(
+			'Starting Worker: tasks=%s',
+			len(self.tasks),
+		)
+		try:
+			startup(self)
+			if self.inspector is not None:
+				self.inspector.start(self)
+			self.logger.debug('Connecting to broker')
+			self.broker.connect()
+			self.logger.debug('Broker connected')
+			for setup in self.setups:
+				self.logger.debug(
+					'Starting Worker setup: hook=%s',
+					type(setup).__qualname__,
+				)
+				setup(self)
+				self.logger.debug(
+					'Worker setup completed: hook=%s',
+					type(setup).__qualname__,
+				)
+			if not isinstance(self.broker, GetConsumer):
+				raise TypeError('Worker broker must support consumer creation')
+			self.consumer = self.broker.consumer()
+			self.logger.debug('Consumer created')
+			for run in self.tasks:
+				self.logger.debug(
+					'Subscribing task: task=%s.%s',
+					run.__module__,
+					run.__qualname__,
+				)
+				self.consumer.subs(
+					run.parameters,
+					Handler(
+						self,
+						run,
+					),
+				)
+				self.logger.debug(
+					'Task subscribed: task=%s.%s',
+					run.__module__,
+					run.__qualname__,
+				)
+			if not self.stopping.is_set():
+				self.running.set()
+				self.logger.info('Worker ready to consume')
+				self.consumer.run()
+		finally:
+			self.running.clear()
+			self.finished.set()
+			if self.pending:
+				self.logger.error(
+					'Consumer exited with unconfirmed deliveries: pending=%s',
+					self.pending,
+				)
+			try:
+				self.logger.info(
+					'Draining Worker tasks: pending=%s',
+					self.pending,
+				)
+				self.pool.stop()
+			finally:
+				try:
+					self.cleanup()
+				finally:
+					try:
+						if self.consumer is not None:
+							self.consumer.close()
+					finally:
+						try:
+							self.broker.close()
+						finally:
+							if self.inspector is not None and self.inspector.worker is self:
+								self.inspector.stop()
+			self.logger.info('Worker shutdown completed')
+
+	def cleanup(self) -> None:
+		self.logger.debug(
+			'Starting Worker cleanup: hooks=%s',
+			len(self.cleanups),
+		)
+		run_cleanups(
+			self.cleanups,
+			self,
+		)
+		self.logger.debug('Worker cleanup completed')
+
+	def stop(self) -> None:
+		if not self.stopping.is_set():
+			self.logger.info(
+				'Worker shutdown requested: pending=%s',
+				self.pending,
+			)
+		self.stopping.set()
+		if self.consumer is not None and not self.finished.is_set():
+			self.consumer.call(self.try_stop)
+
+	def try_stop(self) -> None:
+		if self.stopping.is_set() and self.pending == 0 and self.consumer is not None:
+			self.logger.debug('No pending tasks; requesting Consumer stop')
+			self.consumer.stop()
+
+	def receive(
+		self,
+		run: Type[Run],
+		event: Event,
+	) -> None:
+		if self.stopping.is_set():
+			self.logger.debug(
+				'Requeuing message received during shutdown: task=%s.%s',
+				run.__module__,
+				run.__qualname__,
+			)
+			event.nack()
+			return
+		if not isinstance(
+			event.body,
+			Mapping,
+		):
+			self.failed(
+				run,
+				event,
+				TypeError('Run message body must be a mapping'),
+			)
+			return
+		self.pending += 1
+		consumer = self.consumer
+		if consumer is None:
+			self.pending -= 1
+			raise RuntimeError('Worker consumer is not initialized')
+		inspector = self.inspector
+		task = run.name
+		self.logger.debug(
+			'Task message received: task=%s pending=%s',
+			task,
+			self.pending,
+		)
+		contexts = inspector.begin(task) if inspector is not None else ()
+
+		def schedule(
+			error: Optional[BaseException] = None,
+			result: Any = None,
+		) -> None:
+			if inspector is not None:
+				inspector.end(
+					task,
+					contexts,
+					error is None,
+				)
+			if self.finished.is_set():
+				self.logger.error(
+					'Cannot confirm delivery after Consumer exit: task=%s',
+					task,
+				)
+				return
+			self.logger.debug(
+				'Scheduling task result callback: task=%s success=%s',
+				task,
+				error is None,
+			)
+			consumer.call(lambda: self.complete(
+				run,
+				event,
+				error,
+				result,
+			))
+
+		try:
+			self.logger.debug(
+				'Submitting task to Pool: task=%s',
+				task,
+			)
+			self.pool.submit(
+				run,
+				dict(event.body),
+				callback=lambda result: schedule(result=result),
+				error_callback=schedule,
+			)
+			self.logger.debug(
+				'Pool task submission accepted: task=%s',
+				task,
+			)
+		except PoolFull:
+			self.logger.debug(
+				'Requeuing message because Pool is full: task=%s',
+				task,
+			)
+			if inspector is not None:
+				inspector.end(
+					task,
+					contexts,
+					None,
+				)
+			self.pending -= 1
+			event.nack()
+			return
+		except Exception:
+			if inspector is not None:
+				inspector.end(
+					task,
+					contexts,
+					None,
+				)
+			self.pending -= 1
+			raise
+
+	def complete(
+		self,
+		run: Type[Run],
+		event: Event,
+		error: Optional[BaseException] = None,
+		result: Any = None,
+	) -> None:
+		try:
+			if error is not None:
+				self.failed(
+					run,
+					event,
+					error,
+				)
+			else:
+				if self.consumer is None:
+					raise RuntimeError('Worker consumer is not initialized')
+				self.consumer.complete(
+					event,
+					result,
+				)
+				self.logger.debug(
+					'Consumer completion returned: task=%s.%s',
+					run.__module__,
+					run.__qualname__,
+				)
+		finally:
+			self.pending -= 1
+			self.logger.debug(
+				'Task completion handling finished: pending=%s',
+				self.pending,
+			)
+			self.try_stop()
+
+	def failed(
+		self,
+		run: Type[Run],
+		event: Event,
+		error: BaseException,
+	) -> None:
+		if isinstance(
+			error,
+			TypeError,
+		) and not isinstance(
+			event.body,
+			Mapping,
+		):
+			self.logger.warning(
+				'Rejected a non-mapping task message: task=%s.%s',
+				run.__module__,
+				run.__qualname__,
+			)
+		else:
+			self.logger.error(
+				'Task failed: task=%s.%s',
+				run.__module__,
+				run.__qualname__,
+				exc_info=(
+					type(error),
+					error,
+					error.__traceback__,
+				),
+			)
+		if self.consumer is None:
+			raise RuntimeError('Worker consumer is not initialized')
+		self.consumer.fail(
+			event,
+			run.on_error,
+		)
+		self.logger.debug(
+			'Consumer failure policy returned: task=%s.%s',
+			run.__module__,
+			run.__qualname__,
+		)
+
+
+class Handler(EventHandler):
+	def __init__(
+		self,
+		worker: Worker,
+		run: Type[Run],
+	):
+		self.worker = worker
+		self.run = run
+
+	def __call__(
+		self,
+		event: Event,
+	) -> None:
+		self.worker.receive(
+			self.run,
+			event,
+		)

DefStream/Worker/__init__.py

@@ -0,0 +1,47 @@
+from .Worker import (
+	Worker,
+	WorkerSetup,
+	WorkerCleanup,
+)
+from .Message import (
+	declare,
+	emit,
+	request,
+)
+from .Run import (
+	Run,
+	Context,
+	RunSetup,
+	RunComplete,
+	RunError,
+)
+from .Specification import Specification
+from .Pool import (
+	Pool,
+	PoolFull,
+	PoolSetup,
+	PoolCleanup,
+	ThreadPool,
+	ProcessPool,
+)
+
+__all__ = (
+	'Worker',
+	'declare',
+	'emit',
+	'request',
+	'WorkerSetup',
+	'WorkerCleanup',
+	'Run',
+	'Specification',
+	'Pool',
+	'PoolFull',
+	'PoolSetup',
+	'PoolCleanup',
+	'ThreadPool',
+	'ProcessPool',
+	'Context',
+	'RunSetup',
+	'RunComplete',
+	'RunError',
+)

defstream-0.1.18.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: DefStream
+Version: 0.1.18
+Summary: Synchronous message processing with pluggable broker adapters
+Home-page: https://github.com/yong5eon/DefStream
+Author: Heo Yongseon
+Project-URL: Source, https://github.com/yong5eon/DefStream
+Project-URL: Issues, https://github.com/yong5eon/DefStream/issues
+Project-URL: Releases, https://github.com/yong5eon/DefStream/releases
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: rabbitmq
+Requires-Dist: pika>=1.3.2; extra == "rabbitmq"
+Provides-Extra: redis
+Requires-Dist: redis>=5.1.1; extra == "redis"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+# DefStream
+
+Synchronous event/message processing with pluggable broker adapters
+
+DefStream processes broker messages with ordinary Python task methods and can run them in thread or process pools. It requires Python 3.9 or later.
+
+## Installation
+
+Install the client extra for the broker you use. A broker server must be available separately.
+
+```shell
+python -m pip install "DefStream[RabbitMQ]"
+```
+
+For Redis Streams, install `DefStream[Redis]`. To install both clients, use `DefStream[RabbitMQ,Redis]`. The plain `DefStream` installation includes neither broker client.
+
+## Quick start
+
+The following worker listens to a local RabbitMQ server at `127.0.0.1:5672`. The example credentials are for local development only.
+
+```python
+from signal import SIGINT, signal
+
+from DefStream.Broker.Implements.RabbitMQ import Configuration, Connection, Reject, Subscription
+from DefStream.Worker import Run, ThreadPool, Worker, WorkerSetup, declare
+
+
+class Add(
+  Run,
+  parameters=Subscription(queue='example.add', error='example.add.error'),
+  on_error=Reject(),
+):
+  def run(self, a: int, b: int):
+    print(a + b)
+    return a + b
+
+
+class Prepare(WorkerSetup):
+  def __call__(self, worker: Worker) -> None:
+    for task in worker.tasks:
+      declare(task=task, broker=worker.broker)
+
+
+if __name__ == '__main__':
+  worker = Worker(
+    Connection(Configuration(host='127.0.0.1', port=5672, username='guest', password='guest')),
+    ThreadPool(4),
+    setups=Prepare(),
+  )
+  worker.add(Add)
+  signal(SIGINT, lambda *_: worker.stop())
+  worker.run()
+```
+
+Run the script after starting RabbitMQ. The worker declares its task queue and waits for messages. Store production credentials outside source code.
+
+## License
+
+See the `LICENSE` file included with the source distribution for the license terms.

defstream-0.1.18.dist-info/RECORD

@@ -0,0 +1,75 @@
+DefStream/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+DefStream/Broker/Configuration.py,sha256=cf-sjY9knNCGUWd6dKZClyTzB-mvPYfSuvSTTFALhjo,345
+DefStream/Broker/Connection.py,sha256=KWJDcLq3zYYaytgrTdDZcCoZWGd7KU6B2trAPsen0GU,2125
+DefStream/Broker/Consumer.py,sha256=6zfOSO1gLDkF53TbDRzSp9GCDbL_zOIwz9B2WpMR748,1258
+DefStream/Broker/Errors.py,sha256=_l1ieD1vBbX8MLXEzTK8m_21-8o0Szix3Pg-DNY0aNQ,206
+DefStream/Broker/Event.py,sha256=dIfqIjjlnxlO7UTZEhovUKErJSKd4XmjENlmphLwtnU,470
+DefStream/Broker/Policies.py,sha256=pTur9yqDalStCpMMD0I7yYtJSv0BDt9DIgPMtIgRkpA,273
+DefStream/Broker/Priority.py,sha256=PKxjpMkQEOIOT_cZjG8J6IA7tdQBk3xqQVNG0a7xU7c,621
+DefStream/Broker/Protocol.py,sha256=oYvZaFCIXDroY1Z-iJ6yUelOyrLDDEJMV1ML8_ugEZw,559
+DefStream/Broker/__init__.py,sha256=z_FLeH6QNeoHASnn940fUOnLaMbIE5SDypxDcjZy-JU,866
+DefStream/Broker/Implements/__init__.py,sha256=iwhKnzeBJLKxpRVjvzwiRE63_zNpIBfaKLITauVph-0,24
+DefStream/Broker/Implements/RabbitMQ/Configuration.py,sha256=sHysXc1nlJHbSjWD3BZxlXjKBAbz2AKDtr7ACVVVj0c,1094
+DefStream/Broker/Implements/RabbitMQ/Connection.py,sha256=CSL-0wyiCm1O2AGaN3Pwso_DUrj3VonH8Z3Vco8Ft9A,14198
+DefStream/Broker/Implements/RabbitMQ/Consumer.py,sha256=G3LbXvntZnCTGM-8TfTOed5NF7_qMgk7ZFslSmlIqQo,9686
+DefStream/Broker/Implements/RabbitMQ/Event.py,sha256=j7GjKsVA64-x8ScjAMBrobVF75RE_BXEh6tWXXdS-FI,3086
+DefStream/Broker/Implements/RabbitMQ/Exchange.py,sha256=hn-P-PXCa8v7CzB4yxO1hM04-hDaU7_rACnKvZJHoU4,8476
+DefStream/Broker/Implements/RabbitMQ/Policies.py,sha256=E0NA3zvO1h6BPr7CyMo9WPy6ztobuTd6fGUFgB8604o,90
+DefStream/Broker/Implements/RabbitMQ/Queue.py,sha256=iEdDj8ji35p4ak8JwqsnhUZPvdhtFfQW3RN_YKacFow,9429
+DefStream/Broker/Implements/RabbitMQ/Serializer.py,sha256=PbL_V89GHPjqh1zvOM-apExhD7Bgau2jinpVCsVUg00,1718
+DefStream/Broker/Implements/RabbitMQ/Stream.py,sha256=sgX0otKZMqDKK2eX1S1zkhCo6OhGEr1qyLEpvvwTijY,5694
+DefStream/Broker/Implements/RabbitMQ/Subscription.py,sha256=A1sCwWgytNYOIJ-D9PKps_1blxJNp1lGK0a1CDHh7Jw,1849
+DefStream/Broker/Implements/RabbitMQ/__init__.py,sha256=Ndt5yNXcgecN1mj0Qv7M32LUFK96WKmSi88wKMB1ZdU,673
+DefStream/Broker/Implements/Redis/Configuration.py,sha256=A86E44Jo2z_d45xBHH92atR-PPyySlT7QWgxc3UX1Yc,1551
+DefStream/Broker/Implements/Redis/Connection.py,sha256=CMyVSp4uiyVDIe4y5JQtNNqycksAvGw5Ed8uXyK2RCY,5258
+DefStream/Broker/Implements/Redis/Consumer.py,sha256=-b-2tfa2BCIGqVsf9AkKDnedDkHZ56g7eRRlUHEz6QY,8608
+DefStream/Broker/Implements/Redis/Event.py,sha256=L4kugJefdlEKfCpgbxdBoj9818y9nuL7PECsoXDDfH8,4397
+DefStream/Broker/Implements/Redis/Queue.py,sha256=ndRkp6vh4C7Pp_E0alAjsqHqPm9ban4Kxd4Xi_NeJZw,6097
+DefStream/Broker/Implements/Redis/Serializer.py,sha256=NWGxpnf5kegR9i_kr8cxQk5JiXO1lMdvTo2sPmghHe0,635
+DefStream/Broker/Implements/Redis/Subscription.py,sha256=I6MZdT8-VSBeiGBHuOmld11xwiQv048YQLfRGS9FzSE,811
+DefStream/Broker/Implements/Redis/__init__.py,sha256=mYLkr6H040-cphMjTFv6j-_75q9qusEYPMY97erfjAQ,449
+DefStream/Descriptor/DataObject.py,sha256=hq7YufF6_NCs41TFUozpwFv6qI5iv3Cx5SHHq2IPeLc,12018
+DefStream/Descriptor/Types.py,sha256=tnC9ZjsCx8e_zK5pXjJymx-UxRJNQPBPMxrfMyG2fIE,5112
+DefStream/Descriptor/Value.py,sha256=dSEVedEc9glv3sWC4idUdW0EXtstCW7It2WeZfTGYF0,3525
+DefStream/Descriptor/__init__.py,sha256=xu_dDulMEItY6d7OjMZptsBb9_zdH--rqPTTnkz8ZGg,2544
+DefStream/Inspector/Extension.py,sha256=4VqIVtsMpeLzsnlG1fWVif1mBv3BakC7L1fFVso4gvc,954
+DefStream/Inspector/Inspector.py,sha256=Oq5-YBLLORCw2GtnyGVHcY-3yUYXksQPgc7P-hbfPoU,7323
+DefStream/Inspector/Response.py,sha256=QtXyorMAize6iM08so3k-WY1PdArjE6VK3Lixjz6WvA,204
+DefStream/Inspector/__init__.py,sha256=O1rJuT-n92AY3Z3im6XJ13mqaI67wpMQmbPwLDBbOQU,153
+DefStream/Inspector/Extensions/Console.html,sha256=5xyI-JWbTKje9tdcIAXnfIyuBqLT72EWmWAto387RfQ,21024
+DefStream/Inspector/Extensions/Console.py,sha256=EXCnwxmVPy1N4y6w15m36ZysTf0brltlMvstszclmmM,10052
+DefStream/Inspector/Extensions/Metrics.py,sha256=WKusp_ZvZi5vV3zhncdURjTzmNRpaAnixFQtthpjx-8,8351
+DefStream/Inspector/Extensions/Ping.py,sha256=EZ2nyzTbbYjbRoFjdidgNCW-3BWIPoWpOzBGDreA5JQ,2391
+DefStream/Inspector/Extensions/Specifications.py,sha256=l1F-LguRPBvE1EaSq_4nQKpjctpV6OdNZs0BVR3I0KM,3841
+DefStream/Inspector/Extensions/Status.html,sha256=PBYBVzV1pgwST89_CIX_jhXHGwKQrpoL-KEyrzuKkJE,12060
+DefStream/Inspector/Extensions/Status.py,sha256=2qidtJiK6xMC56deLzfXdr6xJdOPdc51oSsjKiGXNYs,2795
+DefStream/Inspector/Extensions/__init__.py,sha256=f6ktG84sWLNFVfDLrBtkWl4hjhIrwblRZ990raGATFo,229
+DefStream/Validator/Pattern.py,sha256=gRRlEzS908b9OCXRpFnEG4gujNKCSTlhPUGwWGi-Dqg,674
+DefStream/Validator/Validate.py,sha256=2Edk1sWh5_4QdYTc1xakDLPXMAWNrrjso1TLi7ZQ4Gg,700
+DefStream/Validator/Validator.py,sha256=lvJGzDKecKIBAQrfFuSHBRUh6PCxiHRsabul6cYxcdA,556
+DefStream/Validator/__init__.py,sha256=juhR_lm3XpqU-BUnTjbaYbFNXa_zs9Xi9-x_9EyvJgE,172
+DefStream/Validator/Patterns/Array.py,sha256=XPc88iPhU2k30TIyMsB6pdDqUO_wjv-5YP96mTHbApc,514
+DefStream/Validator/Patterns/Common.py,sha256=JJIOAcPO6epnIINaVu5SuwmnQoK3rLQn6vYyZ3JBuX8,1817
+DefStream/Validator/Patterns/Compare.py,sha256=5xYVvaiQydvIi8WYgIADltSk0tz_ki76k-c89vZsFcw,3726
+DefStream/Validator/Patterns/Condition.py,sha256=V8iEG9onH6bxlUnqFY8jDdmm6BIx2SBeEJAluVHeEUM,1135
+DefStream/Validator/Patterns/DataObject.py,sha256=BTdbKGSYs1ebXNXmKP2m3T0iJeTBxIwgwl45gacpuUA,2258
+DefStream/Validator/Patterns/DateTime.py,sha256=2ejPyRxFbvWf_0FmUrtXTBTvMnp8nakfW_TyCsRY_h4,2515
+DefStream/Validator/Patterns/Number.py,sha256=k59Ue1Sw-D1iWz8OywjQljPVXdZlTawSl9jBpPjJKKY,919
+DefStream/Validator/Patterns/Object.py,sha256=94aa5eC35dZyrgBlbAEH5eB7v9YB8k_haru_EBeU1vw,3563
+DefStream/Validator/Patterns/Size.py,sha256=n-PdMTYNCw0-KN2wqWqK7nN6smVvrGLO4YfwBLlGA9Y,2016
+DefStream/Validator/Patterns/String.py,sha256=sR4s0GM1J8r1kiOyu4HkDUgIrz-9PvLthHM1IFTgSqw,1805
+DefStream/Validator/Patterns/Type.py,sha256=-z75Q3vYw6Br7T-gACIZNLV2PLLkFdHn67VcLxTDqEs,8758
+DefStream/Validator/Patterns/__init__.py,sha256=2Kkk6BrvcLl0C22I0WhGphp2dF55Ig2b3LY0DMDNWm8,1603
+DefStream/Worker/Executor.py,sha256=1-WSJOVC7LYeXq34OQNr7TFo98LbjvRvkyX8GheqXLk,8024
+DefStream/Worker/Message.py,sha256=JG2I-398YpfAlcCqzds0sFQ35UrqAPZbmdaQTmQ7RyE,3242
+DefStream/Worker/Pool.py,sha256=_LD38ZHq5-T1U8u8Trus_T3bR_IuP0hP8vV2YNz3gDA,4830
+DefStream/Worker/Run.py,sha256=Ik1Ej_NBuMl9sUA1Bw1gTYo3r2QNcKiZl6jRQMucf-A,7392
+DefStream/Worker/Specification.py,sha256=MRPpHtSKYaDAa6t0vitCJCiCwQRL9QmG1Y2zibv_UWU,1807
+DefStream/Worker/Startup.py,sha256=vuGfGHzJcx3vCBZAEs3UxDyzHKKW7U9lWUEkeFTAyN4,3955
+DefStream/Worker/Worker.py,sha256=6RHkKCe-zcVKNCO7y69OGjOGdUUtXF3MRtP1WLEeWXo,8785
+DefStream/Worker/__init__.py,sha256=TG_Ma2HFLi5DKTPbqKZ5VWR28g-_WhsKcrf3iYLJxcw,578
+defstream-0.1.18.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+defstream-0.1.18.dist-info/METADATA,sha256=hneB1u-ydeKj38S1kLPXXVYLFFOpBKii2-W4TxovNj0,2938
+defstream-0.1.18.dist-info/WHEEL,sha256=gRtyB-Pg_pXsUWjiW8ODP1rRp2RMPXkI9uiRVCZyu0A,101
+defstream-0.1.18.dist-info/top_level.txt,sha256=zsnisIu5wHL4b7VM8e9AggG9KTSdUU4morFqpb8YWFs,10
+defstream-0.1.18.dist-info/RECORD,,

defstream-0.1.18.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+Build: 74
+