hunterMakesPy 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

hunterMakesPy/__init__.py

@@ -1,7 +1,5 @@
 """A modular toolkit for defensive programming, parameter validation, file system utilities, and data structure manipulation.
 
-(AI generated docstring)
-
 This package provides:
 - Defensive programming helpers for handling `None` values and error propagation.
 - Parameter and input validation, integer parsing, and concurrency limit utilities.
@@ -9,9 +7,10 @@ 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 raiseIfNone as raiseIfNone
+from hunterMakesPy.coping import PackageSettings as PackageSettings, raiseIfNone as raiseIfNone
 
 from hunterMakesPy.parseParameters import (defineConcurrencyLimit as defineConcurrencyLimit, intInnit as intInnit,
 	oopsieKwargsie as oopsieKwargsie)
@@ -20,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/_theSSOT.py

@@ -1,40 +1,4 @@
-"""Primary: settings for this package.
+"""Settings for this package."""
+from hunterMakesPy import PackageSettings
 
-Secondary: settings for manufacturing.
-Tertiary: hardcoded values until I implement a dynamic solution.
-"""
-from importlib.util import find_spec
-from pathlib import Path
-from tomli import loads as tomli_loads
-from typing import TYPE_CHECKING
-import dataclasses
-
-if TYPE_CHECKING:
-	from importlib.machinery import ModuleSpec
-
-try:
-	identifierPackagePACKAGING: str = tomli_loads(Path("pyproject.toml").read_text(encoding="utf-8"))["project"]["name"]
-except Exception:  # noqa: BLE001
-	identifierPackagePACKAGING = "hunterMakesPy"
-
-def getPathPackageINSTALLING() -> Path:
-    """Return the root directory of the installed package."""
-    try:
-        moduleSpecification: ModuleSpec | None = find_spec(identifierPackagePACKAGING)
-        if moduleSpecification and moduleSpecification.origin:
-            pathFilename = Path(moduleSpecification.origin)
-            return pathFilename.parent if pathFilename.is_file() else pathFilename
-    except ModuleNotFoundError:
-        pass
-    return Path.cwd()
-
-@dataclasses.dataclass
-class PackageSettings:
-	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
-	"""Default file extension for generated code files."""
-	identifierPackage: str = dataclasses.field(default = identifierPackagePACKAGING, metadata={'evaluateWhen': 'packaging'})
-	"""Name of this package, used for import paths and configuration."""
-	pathPackage: Path = dataclasses.field(default_factory=getPathPackageINSTALLING, metadata={'evaluateWhen': 'installing'})
-	"""Absolute path to the installed package directory."""
-
-settingsPackage = PackageSettings()
+settingsPackage = PackageSettings(identifierPackageFALLBACK="hunterMakesPy")

hunterMakesPy/coping.py

@@ -1,13 +1,89 @@
-"""Utility functions for handling `None` values and coping with common programming patterns.
+"""Package configuration and defensive programming utilities for Python projects."""
+from importlib.util import find_spec
+from pathlib import Path
+from tomllib import loads as tomllib_loads
+from typing import TYPE_CHECKING, TypeVar
+import dataclasses
 
-(AI generated docstring)
+if TYPE_CHECKING:
+	from importlib.machinery import ModuleSpec
 
-This module provides helper functions for defensive programming and error handling, particularly for dealing with `None` values that should not occur in correct program flow.
+TypeSansNone = TypeVar('TypeSansNone')
 
-"""
-from typing import TypeVar
+def getIdentifierPackagePACKAGING(identifierPackageFALLBACK: str) -> str:
+	"""Get package name from pyproject.toml or fallback to provided value."""
+	try:
+		return tomllib_loads(Path('pyproject.toml').read_text(encoding='utf-8'))['project']['name']
+	except Exception:  # noqa: BLE001
+		return identifierPackageFALLBACK
+
+def getPathPackageINSTALLING(identifierPackage: str) -> Path:
+	"""Return the root directory of the installed package."""
+	try:
+		moduleSpecification: ModuleSpec | None = find_spec(identifierPackage)
+		if moduleSpecification and moduleSpecification.origin:
+			pathFilename = Path(moduleSpecification.origin)
+			return pathFilename.parent if pathFilename.is_file() else pathFilename
+	except ModuleNotFoundError:
+		pass
+	return Path.cwd()
+
+@dataclasses.dataclass
+class PackageSettings:
+	"""Configuration container for Python package metadata and runtime settings.
+
+	This `class` provides a simple way to store and access basic information about a Python package, It will automatically resolve
+	package identifiers and installation paths if they are not passed to the `class` constructor. Python `dataclasses` are easy to
+	subtype and extend.
 
-TypeSansNone = TypeVar('TypeSansNone')
+	Parameters
+	----------
+	identifierPackageFALLBACK : str = ''
+		Fallback package identifier used only during initialization when automatic discovery fails.
+	pathPackage : Path = Path()
+		Absolute path to the installed package directory. Automatically resolved from `identifierPackage` if not provided.
+	identifierPackage : str = ''
+		Canonical name of the package. Automatically extracted from `pyproject.toml`.
+	fileExtension : str = '.py'
+		Default file extension.
+
+	Examples
+	--------
+	Automatic package discovery from development environment:
+
+	```python
+	settings = PackageSettings(identifierPackageFALLBACK='cobraPy')
+	# Automatically discovers package name from pyproject.toml
+	# Resolves installation path from package identifier
+	```
+
+	Explicit configuration for specific deployment:
+
+	```python
+	settings = PackageSettings(
+		identifierPackage='cobraPy',
+		pathPackage=Path('/opt/tenEx/packages/cobraPy'),
+		fileExtension='.pyx'
+	)
+	```
+
+	"""
+
+	identifierPackageFALLBACK: dataclasses.InitVar[str] = ''
+	"""Fallback package identifier used during initialization only."""
+	pathPackage: Path = dataclasses.field(default_factory=Path, metadata={'evaluateWhen': 'installing'})
+	"""Absolute path to the installed package."""
+	identifierPackage: str = dataclasses.field(default='', metadata={'evaluateWhen': 'packaging'})
+	"""Name of this package."""
+	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
+	"""Default file extension for files."""
+
+	def __post_init__(self, identifierPackageFALLBACK: str) -> None:
+		"""Initialize computed fields after dataclass initialization."""
+		if not self.identifierPackage and identifierPackageFALLBACK:
+			self.identifierPackage = getIdentifierPackagePACKAGING(identifierPackageFALLBACK)
+		if self.pathPackage == Path() and self.identifierPackage:
+			self.pathPackage = getPathPackageINSTALLING(self.identifierPackage)
 
 def raiseIfNone(returnTarget: TypeSansNone | None, errorMessage: str | None = None) -> TypeSansNone:
 	"""Raise a `ValueError` if the target value is `None`, otherwise return the value: tell the type checker that the return value is not `None`.

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  # noqa: ERA001
-			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.
@@ -249,7 +252,7 @@ def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[str, list[Any] |
 				ImaStr = str(keyName)
 				ImaList = list(keyValue)
 				ePluribusUnum.setdefault(ImaStr, []).extend(ImaList)
-			except TypeError:  # noqa: PERF203
+			except TypeError:
 				if killErroneousDataTypes:
 					continue
 				else:

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):