hunterMakesPy 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

hunterMakesPy/__init__.py

@@ -7,6 +7,7 @@ This package provides:
 - Utilities for string extraction from nested data structures and merging dictionaries of lists.
 
 """
+# pyright: reportUnusedImport=false
 from hunterMakesPy.theTypes import identifierDotAttribute as identifierDotAttribute
 
 from hunterMakesPy.coping import PackageSettings as PackageSettings, raiseIfNone as raiseIfNone
@@ -18,7 +19,11 @@ from hunterMakesPy.filesystemToolkit import (importLogicalPath2Identifier as imp
 	importPathFilename2Identifier as importPathFilename2Identifier, makeDirsSafely as makeDirsSafely,
 	writeStringToHere as writeStringToHere)
 
-from hunterMakesPy.dataStructures import (autoDecodingRLE as autoDecodingRLE, stringItUp as stringItUp,
-	updateExtendPolishDictionaryLists as updateExtendPolishDictionaryLists)
+from hunterMakesPy.dataStructures import stringItUp as stringItUp, updateExtendPolishDictionaryLists as updateExtendPolishDictionaryLists
+
+import sys
+
+if sys.version_info < (3, 14):
+    from hunterMakesPy.dataStructures import autoDecodingRLE as autoDecodingRLE
 
 from hunterMakesPy._theSSOT import settingsPackage

hunterMakesPy/dataStructures.py

@@ -5,156 +5,159 @@ from numpy import integer
 from numpy.typing import NDArray
 from typing import Any
 import more_itertools
-import python_minifier
 import re as regex
+import sys
+
+if sys.version_info < (3, 14):
+	import python_minifier
+
+	def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool = False) -> str:  # noqa: C901, PLR0915
+		"""Transform a NumPy array into a compact, self-decoding run-length encoded string representation.
+
+		This function converts a NumPy array into a string that, when evaluated as Python code,
+		recreates the original array structure. The function employs two compression strategies:
+		1. Python's `range` syntax for consecutive integer sequences
+		2. Multiplication syntax for repeated elements
+
+		The resulting string representation is designed to be both human-readable and space-efficient,
+		especially for large cartesian mappings with repetitive patterns. When this string is used
+		as a data source, Python will automatically decode it into Python `list`, which if used as an
+		argument to `numpy.array()`, will recreate the original array structure.
+
+		Parameters
+		----------
+		arrayTarget : NDArray[integer[Any]]
+			(array2target) The NumPy array to be encoded.
+		assumeAddSpaces : bool = False
+			(assume2add2spaces) Affects internal length comparison during compression decisions.
+			This parameter doesn't directly change output format but influences whether
+			`range` or multiplication syntax is preferred in certain cases. The parameter
+			exists because the Abstract Syntax Tree (AST) inserts spaces in its string
+			representation.
+
+		Returns
+		-------
+		rleString : str
+			(rle2string) A string representation of the array using run-length encoding that,
+			when evaluated as Python code, reproduces the original array structure.
+
+		Notes
+		-----
+		The "autoDecoding" feature means that the string representation evaluates directly
+		to the desired data structure without explicit decompression steps.
+
+		"""
+		def sliceNDArrayToNestedLists(arraySlice: NDArray[integer[Any]]) -> Any:
+			def getLengthOption(optionAsStr: str) -> int:
+				"""`assumeAddSpaces` characters: `,` 1; `]*` 2."""
+				return assumeAddSpaces * (optionAsStr.count(',') + optionAsStr.count(']*') * 2) + len(optionAsStr)
+
+			if arraySlice.ndim > 1:
+				axisOfOperation = 0
+				return [sliceNDArrayToNestedLists(arraySlice[index]) for index in range(arraySlice.shape[axisOfOperation])]
+			if arraySlice.ndim == 1:
+				arraySliceAsList: list[int | range] = []
+				cache_consecutiveGroup_addMe: dict[Iterator[Any], list[int] | list[range]] = {}
+				for consecutiveGroup in more_itertools.consecutive_groups(arraySlice.tolist()):
+					if consecutiveGroup in cache_consecutiveGroup_addMe:
+						addMe = cache_consecutiveGroup_addMe[consecutiveGroup]
+					else:
+						ImaSerious: list[int] = list(consecutiveGroup)
+						ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
+						ImaRangeAsStr = python_minifier.minify(str(ImaRange)).replace('range(0,', 'range(').replace('range', '*range')
 
-def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool = False) -> str:  # noqa: C901, PLR0915
-	"""Transform a NumPy array into a compact, self-decoding run-length encoded string representation.
-
-	This function converts a NumPy array into a string that, when evaluated as Python code,
-	recreates the original array structure. The function employs two compression strategies:
-	1. Python's `range` syntax for consecutive integer sequences
-	2. Multiplication syntax for repeated elements
-
-	The resulting string representation is designed to be both human-readable and space-efficient,
-	especially for large cartesian mappings with repetitive patterns. When this string is used
-	as a data source, Python will automatically decode it into Python `list`, which if used as an
-	argument to `numpy.array()`, will recreate the original array structure.
-
-	Parameters
-	----------
-	arrayTarget : NDArray[integer[Any]]
-		(array2target) The NumPy array to be encoded.
-	assumeAddSpaces : bool = False
-		(assume2add2spaces) Affects internal length comparison during compression decisions.
-		This parameter doesn't directly change output format but influences whether
-		`range` or multiplication syntax is preferred in certain cases. The parameter
-		exists because the Abstract Syntax Tree (AST) inserts spaces in its string
-		representation.
-
-	Returns
-	-------
-	rleString : str
-		(rle2string) A string representation of the array using run-length encoding that,
-		when evaluated as Python code, reproduces the original array structure.
+						option1 = ImaRange
+						option1AsStr = ImaRangeAsStr
+						option2 = ImaSerious
+						option2AsStr = None
 
-	Notes
-	-----
-	The "autoDecoding" feature means that the string representation evaluates directly
-	to the desired data structure without explicit decompression steps.
+						# alpha, potential function
+						option1AsStr = option1AsStr or python_minifier.minify(str(option1))
+						lengthOption1 = getLengthOption(option1AsStr)
 
-	"""
-	def sliceNDArrayToNestedLists(arraySlice: NDArray[integer[Any]]) -> Any:
-		def getLengthOption(optionAsStr: str) -> int:
-			"""`assumeAddSpaces` characters: `,` 1; `]*` 2."""
-			return assumeAddSpaces * (optionAsStr.count(',') + optionAsStr.count(']*') * 2) + len(optionAsStr)
-
-		if arraySlice.ndim > 1:
-			axisOfOperation = 0
-			return [sliceNDArrayToNestedLists(arraySlice[index]) for index in range(arraySlice.shape[axisOfOperation])]
-		if arraySlice.ndim == 1:
-			arraySliceAsList: list[int | range] = []
-			cache_consecutiveGroup_addMe: dict[Iterator[Any], list[int] | list[range]] = {}
-			for consecutiveGroup in more_itertools.consecutive_groups(arraySlice.tolist()):
-				if consecutiveGroup in cache_consecutiveGroup_addMe:
-					addMe = cache_consecutiveGroup_addMe[consecutiveGroup]
-				else:
-					ImaSerious: list[int] = list(consecutiveGroup)
-					ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
-					ImaRangeAsStr = python_minifier.minify(str(ImaRange)).replace('range(0,', 'range(').replace('range', '*range')
+						option2AsStr = option2AsStr or python_minifier.minify(str(option2))
+						lengthOption2 = getLengthOption(option2AsStr)
 
-					option1 = ImaRange
-					option1AsStr = ImaRangeAsStr
-					option2 = ImaSerious
-					option2AsStr = None
+						if lengthOption1 < lengthOption2:
+							addMe = option1
+						else:
+							addMe = option2
 
-					# alpha, potential function
-					option1AsStr = option1AsStr or python_minifier.minify(str(option1))
-					lengthOption1 = getLengthOption(option1AsStr)
+						cache_consecutiveGroup_addMe[consecutiveGroup] = addMe
 
-					option2AsStr = option2AsStr or python_minifier.minify(str(option2))
-					lengthOption2 = getLengthOption(option2AsStr)
+					arraySliceAsList += addMe
 
-					if lengthOption1 < lengthOption2:
-						addMe = option1
+				listRangeAndTuple: list[int | range | tuple[int | range, int]] = []
+				cache_malkovichGrouped_addMe: dict[tuple[int | range, int], list[tuple[int | range, int]] | list[int | range]] = {}
+				for malkovichGrouped in more_itertools.run_length.encode(arraySliceAsList):
+					if malkovichGrouped in cache_malkovichGrouped_addMe:
+						addMe = cache_malkovichGrouped_addMe[malkovichGrouped]
 					else:
-						addMe = option2
+						lengthMalkovich = malkovichGrouped[-1]
+						malkovichAsList = list(more_itertools.run_length.decode([malkovichGrouped]))
+						malkovichMalkovich = f"[{malkovichGrouped[0]}]*{lengthMalkovich}"
 
-					cache_consecutiveGroup_addMe[consecutiveGroup] = addMe
+						option1 = [malkovichGrouped]
+						option1AsStr = malkovichMalkovich
+						option2 = malkovichAsList
+						option2AsStr = None
 
-				arraySliceAsList += addMe
+						# beta, potential function
+						option1AsStr = option1AsStr or python_minifier.minify(str(option1))
+						lengthOption1 = getLengthOption(option1AsStr)
 
-			listRangeAndTuple: list[int | range | tuple[int | range, int]] = []
-			cache_malkovichGrouped_addMe: dict[tuple[int | range, int], list[tuple[int | range, int]] | list[int | range]] = {}
-			for malkovichGrouped in more_itertools.run_length.encode(arraySliceAsList):
-				if malkovichGrouped in cache_malkovichGrouped_addMe:
-					addMe = cache_malkovichGrouped_addMe[malkovichGrouped]
-				else:
-					lengthMalkovich = malkovichGrouped[-1]
-					malkovichAsList = list(more_itertools.run_length.decode([malkovichGrouped]))
-					malkovichMalkovich = f"[{malkovichGrouped[0]}]*{lengthMalkovich}"
+						option2AsStr = option2AsStr or python_minifier.minify(str(option2))
+						lengthOption2 = getLengthOption(option2AsStr)
 
-					option1 = [malkovichGrouped]
-					option1AsStr = malkovichMalkovich
-					option2 = malkovichAsList
-					option2AsStr = None
-
-					# beta, potential function
-					option1AsStr = option1AsStr or python_minifier.minify(str(option1))
-					lengthOption1 = getLengthOption(option1AsStr)
-
-					option2AsStr = option2AsStr or python_minifier.minify(str(option2))
-					lengthOption2 = getLengthOption(option2AsStr)
-
-					if lengthOption1 < lengthOption2:
-						addMe = option1
-					else:
-						addMe = option2
+						if lengthOption1 < lengthOption2:
+							addMe = option1
+						else:
+							addMe = option2
 
-					cache_malkovichGrouped_addMe[malkovichGrouped] = addMe
+						cache_malkovichGrouped_addMe[malkovichGrouped] = addMe
 
-				listRangeAndTuple += addMe
+					listRangeAndTuple += addMe
 
-			return listRangeAndTuple
-		return arraySlice
+				return listRangeAndTuple
+			return arraySlice
 
-	arrayAsNestedLists = sliceNDArrayToNestedLists(arrayTarget)
+		arrayAsNestedLists = sliceNDArrayToNestedLists(arrayTarget)
 
-	arrayAsStr = python_minifier.minify(str(arrayAsNestedLists))
+		arrayAsStr = python_minifier.minify(str(arrayAsNestedLists))
 
-	patternRegex = regex.compile(
-		"(?<!rang)(?:"
-		# Pattern 1: Comma ahead, bracket behind  # noqa: ERA001
-		"(?P<joinAhead>,)\\((?P<malkovich>\\d+),(?P<multiply>\\d+)\\)(?P<bracketBehind>])|"
-		# Pattern 2: Bracket or start ahead, comma behind  # noqa: ERA001
-		"(?P<bracketOrStartAhead>\\[|^.)\\((?P<malkovichMalkovich>\\d+),(?P<multiplyIDK>\\d+)\\)(?P<joinBehind>,)|"
-		# Pattern 3: Bracket ahead, bracket behind  # noqa: ERA001
-		"(?P<bracketAhead>\\[)\\((?P<malkovichMalkovichMalkovich>\\d+),(?P<multiply_whatever>\\d+)\\)(?P<bracketBehindBracketBehind>])|"
-		# Pattern 4: Comma ahead, comma behind  # noqa: ERA001
-		"(?P<joinAheadJoinAhead>,)\\((?P<malkovichMalkovichMalkovichMalkovich>\\d+),(?P<multiplyOrSomething>\\d+)\\)(?P<joinBehindJoinBehind>,)"
-		")"
-	)
+		patternRegex = regex.compile(
+			"(?<!rang)(?:"
+			# Pattern 1: Comma ahead, bracket behind  # noqa: ERA001
+			"(?P<joinAhead>,)\\((?P<malkovich>\\d+),(?P<multiply>\\d+)\\)(?P<bracketBehind>])|"
+			# Pattern 2: Bracket or start ahead, comma behind  # noqa: ERA001
+			"(?P<bracketOrStartAhead>\\[|^.)\\((?P<malkovichMalkovich>\\d+),(?P<multiplyIDK>\\d+)\\)(?P<joinBehind>,)|"
+			# Pattern 3: Bracket ahead, bracket behind  # noqa: ERA001
+			"(?P<bracketAhead>\\[)\\((?P<malkovichMalkovichMalkovich>\\d+),(?P<multiply_whatever>\\d+)\\)(?P<bracketBehindBracketBehind>])|"
+			# Pattern 4: Comma ahead, comma behind  # noqa: ERA001
+			"(?P<joinAheadJoinAhead>,)\\((?P<malkovichMalkovichMalkovichMalkovich>\\d+),(?P<multiplyOrSomething>\\d+)\\)(?P<joinBehindJoinBehind>,)"
+			")"
+		)
 
-	def replacementByContext(match: regex.Match[str]) -> str:
-		"""Generate replacement string based on context patterns."""
-		elephino = match.groupdict()
-		joinAhead = elephino.get('joinAhead') or elephino.get('joinAheadJoinAhead')
-		malkovich = elephino.get('malkovich') or elephino.get('malkovichMalkovich') or elephino.get('malkovichMalkovichMalkovich') or elephino.get('malkovichMalkovichMalkovichMalkovich')
-		multiply = elephino.get('multiply') or elephino.get('multiplyIDK') or elephino.get('multiply_whatever') or elephino.get('multiplyOrSomething')
-		joinBehind = elephino.get('joinBehind') or elephino.get('joinBehindJoinBehind')
+		def replacementByContext(match: regex.Match[str]) -> str:
+			"""Generate replacement string based on context patterns."""
+			elephino = match.groupdict()
+			joinAhead = elephino.get('joinAhead') or elephino.get('joinAheadJoinAhead')
+			malkovich = elephino.get('malkovich') or elephino.get('malkovichMalkovich') or elephino.get('malkovichMalkovichMalkovich') or elephino.get('malkovichMalkovichMalkovichMalkovich')
+			multiply = elephino.get('multiply') or elephino.get('multiplyIDK') or elephino.get('multiply_whatever') or elephino.get('multiplyOrSomething')
+			joinBehind = elephino.get('joinBehind') or elephino.get('joinBehindJoinBehind')
 
-		replaceAhead = "]+[" if joinAhead == "," else "["
+			replaceAhead = "]+[" if joinAhead == "," else "["
 
-		replaceBehind = "+[" if joinBehind == "," else ""
+			replaceBehind = "+[" if joinBehind == "," else ""
 
-		return f"{replaceAhead}{malkovich}]*{multiply}{replaceBehind}"
+			return f"{replaceAhead}{malkovich}]*{multiply}{replaceBehind}"
 
-	arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
-	arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
+		arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
+		arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
 
-	# Replace `range(0,stop)` syntax with `range(stop)` syntax.  # noqa: ERA001
-	# Add unpack operator `*` for automatic decoding when evaluated.
-	return arrayAsStr.replace('range(0,', 'range(').replace('range', '*range')
+		# Replace `range(0,stop)` syntax with `range(stop)` syntax.  # noqa: ERA001
+		# Add unpack operator `*` for automatic decoding when evaluated.
+		return arrayAsStr.replace('range(0,', 'range(').replace('range', '*range')
 
 def stringItUp(*scrapPile: Any) -> list[str]:  # noqa: C901
 	"""Convert, if possible, every element in the input data structure to a string.

hunterMakesPy/filesystemToolkit.py

@@ -1,6 +1,6 @@
 """File system and module import utilities.
 
-This module provides basic file I/O utilities such as importing callables from modules, and safely creating directories.
+This module provides basic file I/O utilities such as importing callables from modules, safely creating directories, and writing to files or streams (pipes).
 
 """
 
@@ -97,17 +97,25 @@ def makeDirsSafely(pathFilename: Any) -> None:
 		with contextlib.suppress(OSError):
 			Path(pathFilename).parent.mkdir(parents=True, exist_ok=True)
 
-def writeStringToHere(this: str, pathFilename: PathLike[Any] | PurePath) -> None:
-	"""Write a string to a file, creating parent directories as needed.
+def writeStringToHere(this: str, pathFilename: PathLike[Any] | PurePath | io.TextIOBase) -> None:
+	"""Write a string to a file or text stream.
+
+	This function writes a string to either a file path or an open text stream. For file paths, it creates parent directories as
+	needed and writes with UTF-8 encoding. For text streams, it writes directly to the stream and flushes the buffer.
 
 	Parameters
 	----------
 	this : str
-		The string content to write to the file.
-	pathFilename : PathLike[Any] | PurePath
-		The path and filename where the string will be written.
+		The string content to write.
+	pathFilename : PathLike[Any] | PurePath | io.TextIOBase
+		The target destination: either a file path or an open text stream.
 
 	"""
-	pathFilename = Path(pathFilename)
-	makeDirsSafely(pathFilename)
-	pathFilename.write_text(str(this), encoding='utf-8')
+	if isinstance(pathFilename, io.TextIOBase):
+		pathFilename.write(str(this))
+		pathFilename.flush()
+	else:
+		pathFilename = Path(pathFilename)
+		makeDirsSafely(pathFilename)
+		pathFilename.write_text(str(this), encoding='utf-8')
+

hunterMakesPy/parseParameters.py

@@ -9,18 +9,16 @@ import multiprocessing
 class ErrorMessageContext:
 	"""Context information for constructing error messages.
 
-	(AI generated docstring)
-
 	Parameters
 	----------
 	parameterValue : Any = None
-		(parameter2value) The value that caused the error.
+		The value that caused the error.
 	parameterValueType : str | None = None
-		(parameter2value2type) The type name of the parameter value.
+		The name of the type of the parameter value.
 	containerType : str | None = None
-		(container2type) The type name of the container holding the parameter.
+		The name of the type of the container holding the parameter.
 	isElement : bool = False
-		(is2element) Whether the parameter is an element within a container.
+		Whether the parameter is an element within a container.
 
 	"""
 
@@ -32,7 +30,8 @@ class ErrorMessageContext:
 def _constructErrorMessage(context: ErrorMessageContext, parameterName: str, parameterType: type[Any] | None) -> str:
 	"""Construct error message from available context using template.
 
-	I received ["value" | a value | `None`] [of type `type` | `None`] [as an element in | `None`] [a `containerType` type | `None`] but `parameterName` must have integers [in type(s) `parameterType` | `None`].
+	I received ["value" | a value | `None`] [of type `type` | `None`] [as an element in | `None`] [a `containerType` type |
+	`None`] but `parameterName` must have integers [in type(s) `parameterType` | `None`].
 
 	Hypothetically, this is a prototype that can be generalized to other functions. In this package and a few of my other
 	packages, I have developed standardized error messages, but those are quite different from this. I will certainly continue to
@@ -41,16 +40,16 @@ def _constructErrorMessage(context: ErrorMessageContext, parameterName: str, par
 	Parameters
 	----------
 	context : ErrorMessageContext
-		(context) The error context containing parameter value, type, and container information.
+		The error context containing parameter value, type, and container information.
 	parameterName : str
-		(parameter2name) The name of the parameter that caused the error.
+		The name of the parameter that caused the error.
 	parameterType : type[Any] | None
-		(parameter2type) The expected type of the parameter, used in error messages.
+		The expected type of the parameter, used in error messages.
 
 	Returns
 	-------
 	errorMessage : str
-		(error2message) The constructed error message string.
+		The constructed error message string.
 
 	"""
 	messageParts = ["I received "]
@@ -79,7 +78,8 @@ def _constructErrorMessage(context: ErrorMessageContext, parameterName: str, par
 def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int = multiprocessing.cpu_count()) -> int:  # noqa: C901, PYI041
 	"""Determine the concurrency limit based on the provided parameter.
 
-	This package has Pytest tests you can import and run on this function. `from hunterMakesPy.pytest_parseParameters import makeTestSuiteConcurrencyLimit`
+	Tests for this function can be run with:
+	`from hunterMakesPy.tests.test_parseParameters import PytestFor_defineConcurrencyLimit`
 
 	Parameters
 	----------
@@ -92,12 +92,12 @@ def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int =
 	Returns
 	-------
 	concurrencyLimit : int
-		(concurrency2limit) The calculated concurrency limit, ensuring it is at least 1.
+		The calculated concurrency limit, ensuring it is at least 1.
 
 	Notes
 	-----
-	If you want to be extra nice to your users, consider using `hunterMakesPy.oopsieKwargsie()` to handle
-	malformed inputs. For example:
+	If you want to be extra nice to your users, consider using `hunterMakesPy.oopsieKwargsie()` to handle malformed inputs. For
+	example:
 
 	```
 	if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
@@ -163,23 +163,25 @@ def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int =
 def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None, parameterType: type[Any] | None = None) -> list[int]:  # noqa: C901, PLR0912, PLR0915
 	"""Validate and convert input values to a `list` of integers.
 
-	Accepts various numeric types and attempts to convert them into integers while providing descriptive error messages.
+	Accepts various numeric types and attempts to convert them into integers while providing descriptive error messages. This
+	package includes Pytest tests that can be imported and run: `from hunterMakesPy.tests.test_parseParameters import
+	PytestFor_intInnit`.
 
 	Parameters
 	----------
 	listInt_Allegedly : Iterable[Any]
-		(list2int2allegedly) The input sequence that should contain integer-compatible values.
-		Accepts integers, strings, floats, complex numbers, and binary data.
-		Rejects boolean values and non-integer numeric values.
+		The input sequence that should contain integer-compatible values. Accepts integers, strings, floats, complex numbers, and
+		binary data. Rejects boolean values and non-integer numeric values.
 	parameterName : str | None = None
-		(parameter2name) Name of the parameter from your function for which this function is validating the input validated. If there is an error message, it provides context to your user. Defaults to 'the parameter'.
+		Name of the parameter from your function for which this function is validating the input validated. If there is an error
+		message, it provides context to your user. Defaults to 'the parameter'.
 	parameterType : type[Any] | None = None
-		(parameter2type) Expected type(s) of the parameter, used in error messages.
+		Expected type(s) of the parameter, used in error messages.
 
 	Returns
 	-------
 	listValidated : list[int]
-		(list2validated) A `list` containing validated integers.
+		A `list` containing validated integers.
 
 	Raises
 	------
@@ -192,9 +194,6 @@ def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None,
 
 	Notes
 	-----
-	This package includes Pytest tests that can be imported and run:
-	`from hunterMakesPy.pytest_parseParameters import makeTestSuiteIntInnit`
-
 	The function performs strict validation and follows fail-early principles to catch potential issues before they become catastrophic.
 
 	"""
@@ -284,19 +283,20 @@ def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None,
 def oopsieKwargsie(huh: Any) -> bool | None | str:
 	"""Interpret a `str` as `True`, `False`, or `None` to avoid an `Exception`.
 
-	If a calling function passes a `str` to a parameter that shouldn't receive a `str`, `oopsieKwargsie()` might help you avoid an `Exception`. It tries to interpret the string as `True`, `False`, or `None`. This package has Pytest tests you can import and run on this function.
-	`from hunterMakesPy.pytest_parseParameters import makeTestSuiteOopsieKwargsie`
+	If a calling function passes a `str` to a parameter that shouldn't receive a `str`, `oopsieKwargsie()` might help you avoid an
+	`Exception`. It tries to interpret the string as `True`, `False`, or `None`.
+
+	Tests for this function can be run with: `from hunterMakesPy.tests.test_parseParameters import PytestFor_oopsieKwargsie`.
 
 	Parameters
 	----------
 	huh : Any
 		(huh) The input string to be parsed.
 
-
 	Returns
 	-------
 	interpretedValue : bool | None | str
-		(interpreted2value) The reserved keyword `True`, `False`, or `None` or the original string, `huh`.
+		The reserved keyword `True`, `False`, or `None` or the original string, `huh`.
 
 	"""
 	if not isinstance(huh, str):