wip/py-blockbuster: import py313-blockbuster-1.5.24

[Thomas Klausner (via pkgsrc-wip) <commit-notify%pkgsrc.org@localhost>]

Module Name:	pkgsrc-wip
Committed By:	Thomas Klausner <wiz%NetBSD.org@localhost>
Pushed By:	wiz
Date:		Sun Jul 13 11:09:44 2025 +0200
Changeset:	2d14064334b1e06cee262aa96ff0d9c181856049

Added Files:
	py-blockbuster/DESCR
	py-blockbuster/Makefile
	py-blockbuster/PLIST
	py-blockbuster/TODO
	py-blockbuster/distinfo

Log Message:
wip/py-blockbuster: import py313-blockbuster-1.5.24

TODO: Needs forbiddenfruit package.

Blockbuster is a Python package designed to detect and prevent
blocking calls within an asynchronous event loop.  It is particularly
useful when executing tests to ensure that your asynchronous code
does not inadvertently call blocking operations, which can lead to
performance bottlenecks and unpredictable behavior.

In Python, the asynchronous event loop allows for concurrent
execution of tasks without the need for multiple threads or processes.
This is achieved by running tasks cooperatively, where tasks yield
control back to the event loop when they are waiting for I/O
operations or other long-running tasks to complete.

However, blocking calls, such as file I/O operations or certain
networking operations, can halt the entire event loop, preventing
other tasks from running.  This can lead to increased latency and
reduced performance, defeating the purpose of using asynchronous
programming.

The difficulty with blocking calls is that they are not always
obvious, especially when working with third-party libraries or
legacy code.  This is where Blockbuster comes in: it helps you
identify and eliminate blocking calls in your codebase during
testing, ensuring that your asynchronous code runs smoothly and
efficiently.  It does this by wrapping common blocking functions
and raising an exception when they are called within an asynchronous
context.

To see a diff of this commit:
https://wip.pkgsrc.org/cgi-bin/gitweb.cgi?p=pkgsrc-wip.git;a=commitdiff;h=2d14064334b1e06cee262aa96ff0d9c181856049

Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.

diffstat:
 py-blockbuster/DESCR    | 26 ++++++++++++++++++++++++++
 py-blockbuster/Makefile | 20 ++++++++++++++++++++
 py-blockbuster/PLIST    | 12 ++++++++++++
 py-blockbuster/TODO     |  1 +
 py-blockbuster/distinfo |  5 +++++
 5 files changed, 64 insertions(+)

diffs:
diff --git a/py-blockbuster/DESCR b/py-blockbuster/DESCR
new file mode 100644
index 0000000000..6a1bffeff6
--- /dev/null
+++ b/py-blockbuster/DESCR
@@ -0,0 +1,26 @@
+Blockbuster is a Python package designed to detect and prevent
+blocking calls within an asynchronous event loop.  It is particularly
+useful when executing tests to ensure that your asynchronous code
+does not inadvertently call blocking operations, which can lead to
+performance bottlenecks and unpredictable behavior.
+
+In Python, the asynchronous event loop allows for concurrent
+execution of tasks without the need for multiple threads or processes.
+This is achieved by running tasks cooperatively, where tasks yield
+control back to the event loop when they are waiting for I/O
+operations or other long-running tasks to complete.
+
+However, blocking calls, such as file I/O operations or certain
+networking operations, can halt the entire event loop, preventing
+other tasks from running.  This can lead to increased latency and
+reduced performance, defeating the purpose of using asynchronous
+programming.
+
+The difficulty with blocking calls is that they are not always
+obvious, especially when working with third-party libraries or
+legacy code.  This is where Blockbuster comes in: it helps you
+identify and eliminate blocking calls in your codebase during
+testing, ensuring that your asynchronous code runs smoothly and
+efficiently.  It does this by wrapping common blocking functions
+and raising an exception when they are called within an asynchronous
+context.
diff --git a/py-blockbuster/Makefile b/py-blockbuster/Makefile
new file mode 100644
index 0000000000..c05bf6a420
--- /dev/null
+++ b/py-blockbuster/Makefile
@@ -0,0 +1,20 @@
+# $NetBSD$
+
+DISTNAME=	blockbuster-1.5.24
+PKGNAME=	${PYPKGPREFIX}-${DISTNAME}
+CATEGORIES=	devel python
+MASTER_SITES=	${MASTER_SITE_PYPI:=b/blockbuster/}
+
+MAINTAINER=	pkgsrc-users%NetBSD.org@localhost
+HOMEPAGE=	https://github.com/cbornet/blockbuster.git
+COMMENT=	Utility to detect blocking calls in the async event loop
+LICENSE=	apache-2.0
+
+TOOL_DEPENDS+=	${PYPKGPREFIX}-hatchling-[0-9]*:../../devel/py-hatchling
+# forbiddenfruit
+TEST_DEPENDS+=	${PYPKGPREFIX}-requests-[0-9]*:../../devel/py-requests
+
+USE_LANGUAGES=	# none
+
+.include "../../lang/python/wheel.mk"
+.include "../../mk/bsd.pkg.mk"
diff --git a/py-blockbuster/PLIST b/py-blockbuster/PLIST
new file mode 100644
index 0000000000..15767497d1
--- /dev/null
+++ b/py-blockbuster/PLIST
@@ -0,0 +1,12 @@
+@comment $NetBSD$
+${PYSITELIB}/${WHEEL_INFODIR}/METADATA
+${PYSITELIB}/${WHEEL_INFODIR}/RECORD
+${PYSITELIB}/${WHEEL_INFODIR}/WHEEL
+${PYSITELIB}/${WHEEL_INFODIR}/licenses/LICENSE
+${PYSITELIB}/blockbuster/__init__.py
+${PYSITELIB}/blockbuster/__init__.pyc
+${PYSITELIB}/blockbuster/__init__.pyo
+${PYSITELIB}/blockbuster/blockbuster.py
+${PYSITELIB}/blockbuster/blockbuster.pyc
+${PYSITELIB}/blockbuster/blockbuster.pyo
+${PYSITELIB}/blockbuster/py.typed
diff --git a/py-blockbuster/TODO b/py-blockbuster/TODO
new file mode 100644
index 0000000000..464a07c3bb
--- /dev/null
+++ b/py-blockbuster/TODO
@@ -0,0 +1 @@
+Needs unpackaged forbiddenfruit dependency.
diff --git a/py-blockbuster/distinfo b/py-blockbuster/distinfo
new file mode 100644
index 0000000000..373d47ce65
--- /dev/null
+++ b/py-blockbuster/distinfo
@@ -0,0 +1,5 @@
+$NetBSD$
+
+BLAKE2s (blockbuster-1.5.24.tar.gz) = 4c794ebaa1338cd4537dc692c7c1d4a4f63304d19e4e012ebb2215e37b170331
+SHA512 (blockbuster-1.5.24.tar.gz) = f286c1fad7236783aae81111480a43c946819264c7584fe9cdc466cdfff0c63c5076a9c74397e5f37782f5957c68834a1db7640a5aeae2bc0a2961fc472e7824
+Size (blockbuster-1.5.24.tar.gz) = 51245 bytes