hunterMakesPy 0.1.1__tar.gz → 0.2.0__tar.gz

{huntermakespy-0.1.1 → huntermakespy-0.2.0}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.1.1
-Summary: A modular Python toolkit for defensive programming, parameter validation, file system utilities, and flexible data structure manipulation. Provides helpers for error propagation, input validation, concurrency limits, safe directory creation, dynamic module loading, string extraction from nested structures, and dictionary merging.
+Version: 0.2.0
+Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
 Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/
 Project-URL: Issues, https://github.com/hunterhogan/
 Project-URL: Repository, https://github.com/hunterhogan/
-Keywords: defensive programming,parameter validation,input validation,error propagation,concurrency limit,integer parsing,file system utilities,directory creation,dynamic import,module loading,attribute loading,string extraction,nested data structures,dictionary merging,package settings,configuration,pytest,test utilities
+Keywords: attribute loading,concurrency limit,configuration,defensive programming,dictionary merging,directory creation,dynamic import,error propagation,file system utilities,input validation,integer parsing,module loading,nested data structures,package settings,parameter validation,pytest,string extraction,test utilities
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Framework :: Pytest
@@ -17,31 +17,31 @@ Classifier: Intended Audience :: End Users/Desktop
 Classifier: Intended Audience :: Other Audience
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: charset_normalizer
 Requires-Dist: more_itertools
 Requires-Dist: numpy
-Requires-Dist: python_minifier
-Requires-Dist: tomli
+Requires-Dist: python_minifier; python_version < "3.14"
+Provides-Extra: development
+Requires-Dist: mypy; extra == "development"
+Requires-Dist: pyupgrade; extra == "development"
+Requires-Dist: setuptools-scm; extra == "development"
 Provides-Extra: testing
-Requires-Dist: mypy; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
-Requires-Dist: pyupgrade; extra == "testing"
-Requires-Dist: setuptools-scm; extra == "testing"
 Dynamic: license-file
 
 # hunterMakesPy

{huntermakespy-0.1.1 → huntermakespy-0.2.0}/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-0.2.0/hunterMakesPy/_theSSOT.py

@@ -0,0 +1,4 @@
+"""Settings for this package."""
+from hunterMakesPy import PackageSettings
+
+settingsPackage = PackageSettings(identifierPackageFALLBACK="hunterMakesPy")

huntermakespy-0.2.0/hunterMakesPy/coping.py

@@ -0,0 +1,149 @@
+"""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
+
+if TYPE_CHECKING:
+	from importlib.machinery import ModuleSpec
+
+TypeSansNone = TypeVar('TypeSansNone')
+
+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.
+
+	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`.
+
+	(AI generated docstring)
+
+	This is a defensive programming function that converts unexpected `None` values into explicit errors with context. It is useful for asserting that functions that might return `None` have actually returned a meaningful value.
+
+	Parameters
+	----------
+	returnTarget : TypeSansNone | None
+		The value to check for `None`. If not `None`, this value is returned unchanged.
+	errorMessage : str | None = None
+		Custom error message to include in the `ValueError`. If `None`, a default message with debugging hints is used.
+
+	Returns
+	-------
+	returnTarget : TypeSansNone
+		The original `returnTarget` value, guaranteed to not be `None`.
+
+	Raises
+	------
+	ValueError
+		If `returnTarget` is `None`.
+
+	Examples
+	--------
+	Ensure a function result is not `None`:
+
+	```python
+	def findFirstMatch(listItems: list[str], pattern: str) -> str | None:
+		for item in listItems:
+			if pattern in item:
+				return item
+		return None
+
+	listFiles = ['document.txt', 'image.png', 'data.csv']
+	filename = raiseIfNone(findFirstMatch(listFiles, '.txt'))
+	# Returns 'document.txt'
+	```
+
+	Handle dictionary lookups with custom error messages:
+
+	```python
+	configurationMapping = {'host': 'localhost', 'port': 8080}
+	host = raiseIfNone(configurationMapping.get('host'),
+					"Configuration must include 'host' setting")
+	# Returns 'localhost'
+
+	# This would raise ValueError with custom message:
+	# database = raiseIfNone(configurationMapping.get('database'),
+	#                       "Configuration must include 'database' setting")
+	```
+
+	Thanks
+	------
+	sobolevn, https://github.com/sobolevn, for the seed of the function. https://github.com/python/typing/discussions/1997#discussioncomment-13108399
+
+	"""
+	if returnTarget is None:
+		message = errorMessage or 'A function unexpectedly returned `None`. Hint: look at the traceback immediately before `raiseIfNone`.'
+		raise ValueError(message)
+	return returnTarget

huntermakespy-0.2.0/hunterMakesPy/dataStructures.py

@@ -0,0 +1,268 @@
+"""Provides utilities for string extraction from nested data structures and merges multiple dictionaries containing lists into one dictionary."""
+
+from collections.abc import Iterator, Mapping
+from numpy import integer
+from numpy.typing import NDArray
+from typing import Any
+import more_itertools
+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')
+
+						option1 = ImaRange
+						option1AsStr = ImaRangeAsStr
+						option2 = ImaSerious
+						option2AsStr = None
+
+						# alpha, 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
+
+						cache_consecutiveGroup_addMe[consecutiveGroup] = addMe
+
+					arraySliceAsList += addMe
+
+				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}"
+
+						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
+
+						cache_malkovichGrouped_addMe[malkovichGrouped] = addMe
+
+					listRangeAndTuple += addMe
+
+				return listRangeAndTuple
+			return arraySlice
+
+		arrayAsNestedLists = sliceNDArrayToNestedLists(arrayTarget)
+
+		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>,)"
+			")"
+		)
+
+		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 "["
+
+			replaceBehind = "+[" if joinBehind == "," else ""
+
+			return f"{replaceAhead}{malkovich}]*{multiply}{replaceBehind}"
+
+		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')
+
+def stringItUp(*scrapPile: Any) -> list[str]:  # noqa: C901
+	"""Convert, if possible, every element in the input data structure to a string.
+
+	Order is not preserved or readily predictable.
+
+	Parameters
+	----------
+	*scrapPile : Any
+		(scrap2pile) One or more data structures to unpack and convert to strings.
+
+	Returns
+	-------
+	listStrungUp : list[str]
+		(list2strung2up) A `list` of string versions of all convertible elements.
+
+	"""
+	scrap = None
+	listStrungUp: list[str] = []
+
+	def drill(KitKat: Any) -> None:  # noqa: C901, PLR0912
+		match KitKat:
+			case str():
+				listStrungUp.append(KitKat)
+			case bool() | bytearray() | bytes() | complex() | float() | int() | memoryview() | None:
+				listStrungUp.append(str(KitKat)) # pyright: ignore [reportUnknownArgumentType]
+			case dict():
+				for broken, piece in KitKat.items(): # pyright: ignore [reportUnknownVariableType]
+					drill(broken)
+					drill(piece)
+			case list() | tuple() | set() | frozenset() | range():
+				for kit in KitKat: # pyright: ignore [reportUnknownVariableType]
+					drill(kit)
+			case _:
+				if hasattr(KitKat, '__iter__'):  # Unpack other iterables
+					for kat in KitKat:
+						drill(kat)
+				else:
+					try:
+						sharingIsCaring = KitKat.__str__()
+						listStrungUp.append(sharingIsCaring)
+					except AttributeError:
+						pass
+					except TypeError:  # "The error traceback provided indicates that there is an issue when calling the __str__ method on an object that does not have this method properly defined, leading to a TypeError."
+						pass
+					except:
+						print(f"\nWoah! I received '{repr(KitKat)}'.\nTheir report card says, 'Plays well with others: Needs improvement.'\n")  # noqa: RUF010, T201
+						raise
+	try:
+		for scrap in scrapPile:
+			drill(scrap)
+	except RecursionError:
+		listStrungUp.append(repr(scrap))
+	return listStrungUp
+
+def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[str, list[Any] | set[Any] | tuple[Any, ...]], destroyDuplicates: bool = False, reorderLists: bool = False, killErroneousDataTypes: bool = False) -> dict[str, list[Any]]:
+	"""Merge multiple dictionaries containing `list` into a single dictionary.
+
+	With options to handle duplicates, `list` ordering, and erroneous data types.
+
+	Parameters
+	----------
+	*dictionaryLists : Mapping[str, list[Any] | set[Any] | tuple[Any, ...]]
+		(dictionary2lists) Variable number of dictionaries to be merged. If only one dictionary is passed, it will be processed based on the provided options.
+	destroyDuplicates : bool = False
+		(destroy2duplicates) If `True`, removes duplicate elements from the `list`. Defaults to `False`.
+	reorderLists : bool = False
+		(reorder2lists) If `True`, sorts the `list`. Defaults to `False`.
+	killErroneousDataTypes : bool = False
+		(kill2erroneous2data2types) If `True`, skips dictionary keys or dictionary values that cause a `TypeError` during merging. Defaults to `False`.
+
+	Returns
+	-------
+	ePluribusUnum : dict[str, list[Any]]
+		(e2pluribus2unum) A single dictionary with merged `list` based on the provided options. If only one dictionary is passed,
+		it will be cleaned up based on the options.
+
+	Notes
+	-----
+	The returned value, `ePluribusUnum`, is a so-called primitive dictionary (`dict`). Furthermore, every dictionary key is a
+	so-called primitive string (cf. `str()`) and every dictionary value is a so-called primitive `list` (`list`). If
+	`dictionaryLists` has other data types, the data types will not be preserved. That could have unexpected consequences.
+	Conversion from the original data type to a `list`, for example, may not preserve the order even if you want the order to be
+	preserved.
+
+	"""
+	ePluribusUnum: dict[str, list[Any]] = {}
+
+	for dictionaryListTarget in dictionaryLists:
+		for keyName, keyValue in dictionaryListTarget.items():
+			try:
+				ImaStr = str(keyName)
+				ImaList = list(keyValue)
+				ePluribusUnum.setdefault(ImaStr, []).extend(ImaList)
+			except TypeError:
+				if killErroneousDataTypes:
+					continue
+				else:
+					raise
+
+	if destroyDuplicates:
+		for ImaStr, ImaList in ePluribusUnum.items():
+			ePluribusUnum[ImaStr] = list(dict.fromkeys(ImaList))
+	if reorderLists:
+		for ImaStr, ImaList in ePluribusUnum.items():
+			ePluribusUnum[ImaStr] = sorted(ImaList)
+
+	return ePluribusUnum

{huntermakespy-0.1.1 → huntermakespy-0.2.0}/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):

huntermakespy-0.2.0/hunterMakesPy/pytestForYourUse.py

@@ -0,0 +1,10 @@
+"""Pytest tests you can use in your package to test some hunterMakesPy functions.
+
+Each function in this module returns a list of test functions that can be used with `pytest.parametrize`.
+
+Note: These test functions are now in `hunterMakesPy.tests` with all other tests.
+"""
+
+from hunterMakesPy.tests.test_parseParameters import (
+	PytestFor_defineConcurrencyLimit as PytestFor_defineConcurrencyLimit, PytestFor_intInnit as PytestFor_intInnit,
+	PytestFor_oopsieKwargsie as PytestFor_oopsieKwargsie)