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

hunterMakesPy/dataStructures.py

@@ -11,7 +11,7 @@ import sys
 if sys.version_info < (3, 14):
 	import python_minifier
 
-	def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool = False) -> str:  # noqa: C901, PLR0915
+	def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool = False) -> str:
 		"""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,
@@ -159,7 +159,7 @@ if sys.version_info < (3, 14):
 		# 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
+def stringItUp(*scrapPile: Any) -> list[str]:
 	"""Convert, if possible, every element in the input data structure to a string.
 
 	Order is not preserved or readily predictable.
@@ -178,7 +178,7 @@ def stringItUp(*scrapPile: Any) -> list[str]:  # noqa: C901
 	scrap = None
 	listStrungUp: list[str] = []
 
-	def drill(KitKat: Any) -> None:  # noqa: C901, PLR0912
+	def drill(KitKat: Any) -> None:
 		match KitKat:
 			case str():
 				listStrungUp.append(KitKat)
@@ -204,7 +204,7 @@ def stringItUp(*scrapPile: Any) -> list[str]:  # noqa: C901
 					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
+						print(f"\nWoah! I received '{repr(KitKat)}'.\nTheir report card says, 'Plays well with others: Needs improvement.'\n")  # noqa: T201
 						raise
 	try:
 		for scrap in scrapPile:

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

@@ -75,7 +75,7 @@ def _constructErrorMessage(context: ErrorMessageContext, parameterName: str, par
 
 	return "".join(messageParts)
 
-def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int = multiprocessing.cpu_count()) -> int:  # noqa: C901, PYI041
+def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int = multiprocessing.cpu_count()) -> int:
 	"""Determine the concurrency limit based on the provided parameter.
 
 	Tests for this function can be run with:
@@ -84,8 +84,7 @@ def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int =
 	Parameters
 	----------
 	limit : bool | float | int | None
-		Whether and how to limit CPU usage. Accepts `True`/`False`, an integer count, or a fraction of total CPUs. Positive and
-		negative values have different behaviors, see code for details.
+		Whether and how to limit CPU usage. See notes and examples for details how to describe the options to your users.
 	cpuTotal : int = multiprocessing.cpu_count()
 		The total number of CPUs available in the system. Default is `multiprocessing.cpu_count()`.
 
@@ -96,35 +95,40 @@ def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int =
 
 	Notes
 	-----
-	If you want to be extra nice to your users, consider using `hunterMakesPy.oopsieKwargsie()` to handle malformed inputs. For
-	example:
+	Consider using `hunterMakesPy.oopsieKwargsie()` to handle malformed inputs. For example:
 
 	```
 	if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
 		CPUlimit = oopsieKwargsie(CPUlimit)
 	```
 
-	Examples
-	--------
-	Example parameters:
-		CPUlimit: bool | float | int | None
-		CPUlimit: bool | float | int | None = None
+	Example parameters
+	------------------
+	```python
+	CPUlimit: bool | float | int | None
+	CPUlimit: bool | float | int | None = None
+	```
 
-	Example docstring:
-		```python
+	Example docstring
+	-----------------
+	```python
 
-		Arguments:
-			CPUlimit: bool | float | int | None
-				whether and how to limit the CPU usage. See notes for details.
+	Arguments
+	---------
+	CPUlimit: bool | float | int | None
+		Whether and how to limit the the number of available processors used by the function. See notes for details.
 
-		Limits on CPU usage `CPUlimit`:
-			- `False`, `None`, or `0`: No limits on CPU usage; uses all available CPUs. All other values will potentially limit CPU usage.
-			- `True`: Yes, limit the CPU usage; limits to 1 CPU.
-			- Integer `>= 1`: Limits usage to the specified number of CPUs.
-			- Decimal value (`float`) between 0 and 1: Fraction of total CPUs to use.
-			- Decimal value (`float`) between -1 and 0: Fraction of CPUs to *not* use.
-			- Integer `<= -1`: Subtract the absolute value from total CPUs.
-		```
+	Notes
+	-----
+	Limits on CPU usage, `CPUlimit`:
+		- `False`, `None`, or `0`: No limits on processor usage; uses all available processors. All other values will potentially limit processor usage.
+		- `True`: Yes, limit the processor usage; limits to 1 processor.
+		- `int >= 1`: The maximum number of available processors to use.
+		- `0 < float < 1`: The maximum number of processors to use expressed as a fraction of available processors.
+		- `-1 < float < 0`: The number of processors to *not* use expressed as a fraction of available processors.
+		- `int <= -1`: The number of available processors to *not* use.
+		- If the value of `CPUlimit` is a `float` greater than 1 or less than -1, the function truncates the value to an `int` with the same sign as the `float`.
+	```
 
 	"""
 	concurrencyLimit = cpuTotal
@@ -160,7 +164,7 @@ def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int =
 	return max(int(concurrencyLimit), 1)
 
 # ruff: noqa: TRY301
-def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None, parameterType: type[Any] | None = None) -> list[int]:  # noqa: C901, PLR0912, PLR0915
+def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None, parameterType: type[Any] | None = None) -> list[int]:
 	"""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. This

hunterMakesPy/tests/conftest.py

@@ -1,6 +1,7 @@
 # pyright: standard
 from collections.abc import Callable
 from typing import Any
+import io
 import pathlib
 import pytest
 
@@ -12,6 +13,36 @@ pathDataSamples = pathlib.Path("hunterMakesPy/tests/dataSamples")
 def pathTmpTesting(tmp_path: pathlib.Path) -> pathlib.Path:
 	return tmp_path
 
+# Fixture for predictable Python source code samples
+@pytest.fixture
+def dictionaryPythonSourceSamples() -> dict[str, str]:
+	"""Provide predictable Python source code samples for testing."""
+	return {
+		'functionFibonacci': "def fibonacciNumber():\n    return 13\n",
+		'functionPrime': "def primeNumber():\n    return 17\n",
+		'variablePrime': "prime = 19\n",
+		'variableFibonacci': "fibonacci = 21\n",
+		'classCardinal': "class CardinalDirection:\n    north = 'N'\n    south = 'S'\n",
+	}
+
+# Fixture for IO stream objects
+@pytest.fixture
+def streamMemoryString() -> io.StringIO:
+	"""Provide a StringIO object for testing stream operations."""
+	return io.StringIO()
+
+# Fixture for predictable directory names using cardinal directions
+@pytest.fixture
+def listDirectoryNamesCardinal() -> list[str]:
+	"""Provide predictable directory names using cardinal directions."""
+	return ['north', 'south', 'east', 'west']
+
+# Fixture for predictable file content using Fibonacci numbers
+@pytest.fixture
+def listFileContentsFibonacci() -> list[str]:
+	"""Provide predictable file contents using Fibonacci sequence."""
+	return ['fibonacci8', 'fibonacci13', 'fibonacci21', 'fibonacci34']
+
 def uniformTestFailureMessage(expected: Any, actual: Any, functionName: str, *arguments: Any, **keywordArguments: Any) -> str:
 	"""Format assertion message for any test comparison."""
 	listArgumentComponents: list[str] = [str(parameter) for parameter in arguments]

hunterMakesPy/tests/test_filesystemToolkit.py

@@ -1,46 +1,263 @@
 # pyright: standard
 from hunterMakesPy import importLogicalPath2Identifier, importPathFilename2Identifier, makeDirsSafely, writeStringToHere
-from hunterMakesPy.tests.conftest import uniformTestFailureMessage
+from hunterMakesPy.tests.conftest import standardizedEqualTo
 import io
 import math
 import os
 import pathlib
 import pytest
+import sys
+
+@pytest.mark.parametrize(
+	"logicalPathModuleTarget, identifierTarget, packageIdentifierIfRelativeTarget, expectedType",
+	[
+		('math', 'gcd', None, type(math.gcd)),
+		('os.path', 'join', None, type(os.path.join)),
+		('pathlib', 'Path', None, type(pathlib.Path)),
+		('sys', 'version', None, type(sys.version)),
+	]
+)
+def testImportLogicalPath2IdentifierWithAbsolutePaths(
+	logicalPathModuleTarget: str,
+	identifierTarget: str,
+	packageIdentifierIfRelativeTarget: str | None,
+	expectedType: type
+) -> None:
+	"""Test importing identifiers from modules using absolute logical paths."""
+	identifierImported = importLogicalPath2Identifier(logicalPathModuleTarget, identifierTarget, packageIdentifierIfRelativeTarget)
+
+	assert isinstance(identifierImported, expectedType), (
+		f"\nTesting: `importLogicalPath2Identifier({logicalPathModuleTarget}, {identifierTarget}, {packageIdentifierIfRelativeTarget})`\n"
+		f"Expected type: {expectedType}\n"
+		f"Got type: {type(identifierImported)}"
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, identifierTarget, moduleIdentifierTarget, expectedValueWhenCalled",
+	[
+		("def fibonacciNumber():\n    return 13\n", "fibonacciNumber", None, 13),
+		("def primeNumber():\n    return 17\n", "primeNumber", "moduleNorth", 17),
+		("def cardinalDirection():\n    return 'N'\n", "cardinalDirection", "moduleSouth", 'N'),
+		("def fibonacciSequence():\n    return 21\n", "fibonacciSequence", "moduleEast", 21),
+	]
+)
+def testImportPathFilename2IdentifierWithCallables(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	identifierTarget: str,
+	moduleIdentifierTarget: str | None,
+	expectedValueWhenCalled: object
+) -> None:
+	"""Test importing callable identifiers from Python files."""
+	pathFilenameModule = pathTmpTesting / f"moduleTest{hash(pythonSourceTarget) % 89}.py"  # Use prime number 89
+	pathFilenameModule.write_text(pythonSourceTarget)
+
+	standardizedEqualTo(
+		expectedValueWhenCalled,
+		lambda: importPathFilename2Identifier(pathFilenameModule, identifierTarget, moduleIdentifierTarget)(),
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, identifierTarget, moduleIdentifierTarget, expectedValue",
+	[
+		("prime = 23\n", "prime", None, 23),
+		("fibonacci = 34\n", "fibonacci", "moduleWest", 34),
+		("cardinalDirection = 'S'\n", "cardinalDirection", "moduleNorthEast", 'S'),
+		("sequenceValue = 55\n", "sequenceValue", "moduleSouthWest", 55),
+	]
+)
+def testImportPathFilename2IdentifierWithVariables(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	identifierTarget: str,
+	moduleIdentifierTarget: str | None,
+	expectedValue: object
+) -> None:
+	"""Test importing variable identifiers from Python files."""
+	pathFilenameModule = pathTmpTesting / f"moduleTest{hash(pythonSourceTarget) % 97}.py"  # Use prime number 97
+	pathFilenameModule.write_text(pythonSourceTarget)
+
+	standardizedEqualTo(
+		expectedValue,
+		importPathFilename2Identifier,
+		pathFilenameModule,
+		identifierTarget,
+		moduleIdentifierTarget
+	)
+
+
+@pytest.mark.parametrize(
+	"listDirectoryComponents, filenameTarget",
+	[
+		(['north', 'south'], 'fibonacci13.txt'),
+		(['east', 'west', 'northeast'], 'prime17.txt'),
+		(['southwest', 'northwest'], 'fibonacci21.txt'),
+		(['cardinal', 'directions', 'multiple'], 'prime23.txt'),
+	]
+)
+def testMakeDirsSafelyCreatesNestedDirectories(
+	pathTmpTesting: pathlib.Path,
+	listDirectoryComponents: list[str],
+	filenameTarget: str
+) -> None:
+	"""Test that makeDirsSafely creates nested parent directories."""
+	pathDirectoryNested = pathTmpTesting
+	for directoryComponent in listDirectoryComponents:
+		pathDirectoryNested = pathDirectoryNested / directoryComponent
+
+	pathFilenameTarget = pathDirectoryNested / filenameTarget
+	makeDirsSafely(pathFilenameTarget)
+
+	assert pathDirectoryNested.exists() and pathDirectoryNested.is_dir(), (
+		f"\nTesting: `makeDirsSafely({pathFilenameTarget})`\n"
+		f"Expected: Directory {pathDirectoryNested} to exist and be a directory\n"
+		f"Got: exists={pathDirectoryNested.exists()}, is_dir={pathDirectoryNested.is_dir() if pathDirectoryNested.exists() else False}"
+	)
+
+
+@pytest.mark.parametrize(
+	"streamTypeTarget",
+	[
+		io.StringIO(),
+		io.StringIO("initialContent"),
+	]
+)
+def testMakeDirsSafelyWithIOStreamDoesNotRaise(streamTypeTarget: io.IOBase) -> None:
+	"""Test that makeDirsSafely handles IO streams without raising exceptions."""
+	# This test verifies that no exception is raised
+	makeDirsSafely(streamTypeTarget)
+
+	# If we reach this point, no exception was raised
+	assert True
+
+
+@pytest.mark.parametrize(
+	"listDirectoryComponents, filenameTarget, contentTarget",
+	[
+		(['north', 'fibonacci'], 'test13.txt', 'fibonacci content 13'),
+		(['south', 'prime'], 'test17.txt', 'prime content 17'),
+		(['east', 'cardinal'], 'test21.txt', 'cardinal direction east'),
+		(['west', 'sequence'], 'test23.txt', 'sequence value 23'),
+	]
+)
+def testWriteStringToHereCreatesFileAndDirectories(
+	pathTmpTesting: pathlib.Path,
+	listDirectoryComponents: list[str],
+	filenameTarget: str,
+	contentTarget: str
+) -> None:
+	"""Test that writeStringToHere creates directories and writes content to files."""
+	pathDirectoryNested = pathTmpTesting
+	for directoryComponent in listDirectoryComponents:
+		pathDirectoryNested = pathDirectoryNested / directoryComponent
+
+	pathFilenameTarget = pathDirectoryNested / filenameTarget
+	writeStringToHere(contentTarget, pathFilenameTarget)
+
+	assert pathFilenameTarget.exists(), (
+		f"\nTesting: `writeStringToHere({contentTarget}, {pathFilenameTarget})`\n"
+		f"Expected: File {pathFilenameTarget} to exist\n"
+		f"Got: exists={pathFilenameTarget.exists()}"
+	)
+
+	contentActual = pathFilenameTarget.read_text(encoding="utf-8")
+	assert contentActual == contentTarget, (
+		f"\nTesting: `writeStringToHere({contentTarget}, {pathFilenameTarget})`\n"
+		f"Expected content: {contentTarget}\n"
+		f"Got content: {contentActual}"
+	)
+
+
+@pytest.mark.parametrize(
+	"contentTarget",
+	[
+		'fibonacci content 34',
+		'prime content 29',
+		'cardinal direction NE',
+		'sequence value 55',
+	]
+)
+def testWriteStringToHereWithIOStream(contentTarget: str) -> None:
+	"""Test that writeStringToHere writes content to IO streams."""
+	streamMemory = io.StringIO()
+	writeStringToHere(contentTarget, streamMemory)
+
+	contentActual = streamMemory.getvalue()
+	assert contentActual == contentTarget, (
+		f"\nTesting: `writeStringToHere({contentTarget}, StringIO)`\n"
+		f"Expected content: {contentTarget}\n"
+		f"Got content: {contentActual}"
+	)
+
+
+@pytest.mark.parametrize(
+	"logicalPathModuleTarget, identifierTarget, expectedExceptionType",
+	[
+		('nonexistent.module', 'anyIdentifier', ModuleNotFoundError),
+		('math', 'nonexistentFunction', AttributeError),
+		('os.path', 'nonexistentAttribute', AttributeError),
+	]
+)
+def testImportLogicalPath2IdentifierWithInvalidInputs(
+	logicalPathModuleTarget: str,
+	identifierTarget: str,
+	expectedExceptionType: type[Exception]
+) -> None:
+	"""Test that importLogicalPath2Identifier raises appropriate exceptions for invalid inputs."""
+	standardizedEqualTo(
+		expectedExceptionType,
+		importLogicalPath2Identifier,
+		logicalPathModuleTarget,
+		identifierTarget
+	)
+
+
+@pytest.mark.parametrize(
+	"pathFilenameTarget, identifierTarget, expectedExceptionType",
+	[
+		('nonexistent.py', 'anyIdentifier', FileNotFoundError),
+	]
+)
+def testImportPathFilename2IdentifierWithInvalidInputs(
+	pathTmpTesting: pathlib.Path,
+	pathFilenameTarget: str,
+	identifierTarget: str,
+	expectedExceptionType: type[Exception]
+) -> None:
+	"""Test that importPathFilename2Identifier raises appropriate exceptions for invalid inputs."""
+	pathFilenameNonexistent = pathTmpTesting / pathFilenameTarget
+
+	standardizedEqualTo(
+		expectedExceptionType,
+		importPathFilename2Identifier,
+		pathFilenameNonexistent,
+		identifierTarget
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, identifierTarget, expectedExceptionType",
+	[
+		("def validFunction():\n    return 89\n", "nonexistentIdentifier", AttributeError),
+		("validVariable = 97\n", "nonexistentVariable", AttributeError),
+	]
+)
+def testImportPathFilename2IdentifierWithValidFileInvalidIdentifier(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	identifierTarget: str,
+	expectedExceptionType: type[Exception]
+) -> None:
+	"""Test that importPathFilename2Identifier raises AttributeError for nonexistent identifiers in valid files."""
+	pathFilenameModule = pathTmpTesting / f"moduleTest{hash(pythonSourceTarget) % 101}.py"  # Use prime number 101
+	pathFilenameModule.write_text(pythonSourceTarget)
+
+	standardizedEqualTo(
+		expectedExceptionType,
+		importPathFilename2Identifier,
+		pathFilenameModule,
+		identifierTarget
+	)
 
-def testMakeDirsSafelyCreatesParentDirectories(pathTmpTesting: pathlib.Path) -> None:
-	nestedDirectory = pathTmpTesting / "sub1" / "sub2"
-	filePath = nestedDirectory / "dummy.txt"
-	makeDirsSafely(filePath)
-	assert nestedDirectory.exists() and nestedDirectory.is_dir(), uniformTestFailureMessage(True, nestedDirectory.exists() and nestedDirectory.is_dir(), "testMakeDirsSafelyCreatesParentDirectories", filePath)
-
-def testMakeDirsSafelyWithIOBaseDoesNotRaise() -> None:
-	memoryStream = io.StringIO()
-	makeDirsSafely(memoryStream)
-
-def testWriteStringToHereCreatesFileAndWritesContent(pathTmpTesting: pathlib.Path) -> None:
-	nestedDirectory = pathTmpTesting / "a" / "b"
-	filePath = nestedDirectory / "test.txt"
-	writeStringToHere("hello world", filePath)
-	assert filePath.exists(), uniformTestFailureMessage(True, filePath.exists(), "testWriteStringToHereCreatesFileAndWritesContent", filePath)
-	assert filePath.read_text(encoding="utf-8") == "hello world", uniformTestFailureMessage("hello world", filePath.read_text(encoding="utf-8"), "testWriteStringToHereCreatesFileAndWritesContent", filePath)
-
-@pytest.mark.parametrize(
-	"moduleName, identifier, expectedType",
-	[("math", "gcd", type(math.gcd)),("os.path", "join", type(os.path.join))])
-def testImportLogicalPath2Identifier(moduleName: str, identifier: str, expectedType: type) -> None:
-	imported = importLogicalPath2Identifier(moduleName, identifier)
-	assert isinstance(imported, expectedType), uniformTestFailureMessage(expectedType, type(imported), "testImportLogicalPath2Identifier", (moduleName, identifier))
-
-@pytest.mark.parametrize(
-	"source, identifier, expected"
-	, [("def fibonacciNumber():\n    return 13\n", "fibonacciNumber", 13)
-	, ("prime = 17\n", "prime", 17)])
-def testImportPathFilename2Identifier(tmp_path: pathlib.Path, source: str, identifier: str, expected: object) -> None:
-	filePath = tmp_path / "moduleTest.py"
-	filePath.write_text(source)
-	imported = importPathFilename2Identifier(filePath, identifier)
-	if callable(imported):
-		actual = imported()
-	else:
-		actual = imported
-	assert actual == expected, uniformTestFailureMessage(expected, actual, "testImportPathFilename2Identifier", (filePath, identifier))

{huntermakespy-0.2.0.dist-info → huntermakespy-0.2.2.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.2.0
+Version: 0.2.2
 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/
+Project-URL: Homepage, https://github.com/hunterhogan/hunterMakesPy
+Project-URL: Issues, https://github.com/hunterhogan/hunterMakesPy/issues
+Project-URL: Repository, https://github.com/hunterhogan/hunterMakesPy
 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
@@ -74,7 +74,7 @@ def findConfiguration(configName: str) -> dict[str, str] | None:
 
 config = raiseIfNone(
     findConfiguration("database"),
-    "Configuration 'database' is required but not found"
+    "I could not find Configuration 'database', but I need it to continue."
 )
 ```
 
@@ -83,19 +83,19 @@ config = raiseIfNone(
 Parameter validation, integer parsing, and concurrency handling.
 
 ```python
-from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
+import hunterMakesPy as humpy
 
 # Smart concurrency limit calculation
-cpuLimit = defineConcurrencyLimit(limit=0.75)  # Use 75% of available CPUs
-cpuLimit = defineConcurrencyLimit(limit=True)  # Use exactly 1 CPU
-cpuLimit = defineConcurrencyLimit(limit=4)     # Use exactly 4 CPUs
+cpuLimit = humpy.defineConcurrencyLimit(limit=0.75)  # Use 75% of available CPUs
+cpuLimit = humpy.defineConcurrencyLimit(limit=True)  # Use exactly 1 CPU
+cpuLimit = humpy.defineConcurrencyLimit(limit=4)     # Use exactly 4 CPUs
 
 # Robust integer validation
-validatedIntegers = intInnit([1, "2", 3.0, "4"], "port_numbers")
+validatedIntegers = humpy.intInnit([1, "2", 3.0, "4"], "port_numbers")
 
 # String-to-boolean conversion for configuration
 userInput = "True"
-booleanValue = oopsieKwargsie(userInput)  # Returns True
+booleanValue = humpy.oopsieKwargsie(userInput)  # Returns True
 ```
 
 ## File System Utilities
@@ -103,20 +103,15 @@ booleanValue = oopsieKwargsie(userInput)  # Returns True
 Safe file operations and dynamic module importing.
 
 ```python
-from hunterMakesPy import (
-    importLogicalPath2Identifier,
-    importPathFilename2Identifier,
-    makeDirsSafely,
-    writeStringToHere
-)
+import hunterMakesPy as humpy
 
 # Dynamic imports
-gcdFunction = importLogicalPath2Identifier("math", "gcd")
-customFunction = importPathFilename2Identifier("path/to/module.py", "functionName")
+gcdFunction = humpy.importLogicalPath2Identifier("math", "gcd")
+customFunction = humpy.importPathFilename2Identifier("path/to/module.py", "functionName")
 
 # Safe file operations
 pathFilename = Path("deep/nested/directory/file.txt")
-writeStringToHere("content", pathFilename)  # Creates directories automatically
+humpy.writeStringToHere("content", pathFilename)  # Creates directories automatically
 ```
 
 ## Data Structure Manipulation
@@ -124,21 +119,21 @@ writeStringToHere("content", pathFilename)  # Creates directories automatically
 Utilities for string extraction, data flattening, and array compression.
 
 ```python
-from hunterMakesPy import stringItUp, updateExtendPolishDictionaryLists, autoDecodingRLE
+import hunterMakesPy as humpy
 import numpy
 
 # Extract all strings from nested data structures
 nestedData = {"config": [1, "host", {"port": 8080}], "users": ["alice", "bob"]}
-allStrings = stringItUp(nestedData)  # ['config', 'host', 'port', 'users', 'alice', 'bob']
+allStrings = humpy.stringItUp(nestedData)  # ['config', 'host', 'port', 'users', 'alice', 'bob']
 
 # Merge dictionaries containing lists
-dictionaryAlpha = {"servers": ["web1", "web2"], "databases": ["db1"]}
-dictionaryBeta = {"servers": ["web3"], "databases": ["db2", "db3"]}
-merged = updateExtendPolishDictionaryLists(dictionaryAlpha, dictionaryBeta, destroyDuplicates=True)
+dictionaryAlpha = {"servers": ["chicago", "tokyo"], "databases": ["elm"]}
+dictionaryBeta = {"servers": ["mumbai"], "databases": ["oak", "cedar"]}
+merged = humpy.updateExtendPolishDictionaryLists(dictionaryAlpha, dictionaryBeta, destroyDuplicates=True)
 
 # Compress NumPy arrays with run-length encoding
 arrayData = numpy.array([1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9])
-compressed = autoDecodingRLE(arrayData)  # "[1,*range(2,6)]+[5]*2+[*range(6,10)]"
+compressed = humpy.autoDecodingRLE(arrayData)  # "[1,*range(2,6)]+[5]*2+[*range(6,10)]"
 ```
 
 ## Testing
@@ -146,7 +141,7 @@ compressed = autoDecodingRLE(arrayData)  # "[1,*range(2,6)]+[5]*2+[*range(6,10)]
 The package includes comprehensive test suites that you can import and run:
 
 ```python
-from hunterMakesPy.pytestForYourUse import (
+from hunterMakesPy.tests.test_parseParameters import (
     PytestFor_defineConcurrencyLimit,
     PytestFor_intInnit,
     PytestFor_oopsieKwargsie
@@ -158,8 +153,9 @@ for nameOfTest, callablePytest in listOfTests:
     callablePytest()
 
 # Or test your own compatible functions
-@pytest.mark.parametrize("nameOfTest,callablePytest",
-                        PytestFor_intInnit(callableToTest=myFunction))
+@pytest.mark.parametrize(
+  "nameOfTest,callablePytest"
+  , PytestFor_intInnit(callableToTest=myFunction))
 def test_myFunction(nameOfTest, callablePytest):
     callablePytest()
 ```
@@ -178,4 +174,4 @@ Coding One Step at a Time:
 2. Write good code.
 3. When revising, write better code.
 
-[![CC-BY-NC-4.0](https://github.com/hunterhogan/hunterMakesPy/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/hunterMakesPy/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

{huntermakespy-0.2.0.dist-info → huntermakespy-0.2.2.dist-info}/RECORD

@@ -1,20 +1,20 @@
 hunterMakesPy/__init__.py,sha256=bVF1F2Mdo5AOiioEfxKvNrnsa3vCFI16eMK7Oy5O5TU,1450
 hunterMakesPy/_theSSOT.py,sha256=lkLOG3oTIWNKD_ULX55chlUGNqCHgqVIrBvolvK1vbQ,153
 hunterMakesPy/coping.py,sha256=covqNFAwkF9gjafrlAvMdtCO8haFsESQBhO-7s68qSg,5581
-hunterMakesPy/dataStructures.py,sha256=CFyGjmAOoN2MoEPwWwWdwKNXmOXX8kCS3ttMOa2Rsx0,11379
-hunterMakesPy/filesystemToolkit.py,sha256=vDYS0Rc1aP7ETLXHKoO3TfOpuwJQFQW2ybwtJNiIIo4,4305
-hunterMakesPy/parseParameters.py,sha256=DXpyATx7trGBg_8jlO5dXGfLcG8vg_lU3R1sq1rRFOQ,11644
+hunterMakesPy/dataStructures.py,sha256=Ur2Z4Pytb1Lc5ov8Ag_xm3eii16nJR_yMZzBhbS8vpI,11311
+hunterMakesPy/filesystemToolkit.py,sha256=jd7H5UtrIrPiCYWcvNBNa6DAy-2Ewcf21-jbGXg_IVI,4702
+hunterMakesPy/parseParameters.py,sha256=1mwGNVIZ1x23k_di3lhOhQb8QMXMUCHgt7xw3NRzDXs,11814
 hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hunterMakesPy/pytestForYourUse.py,sha256=GiN1C1gTTM0ZunRPEMnrKlLQLMdH0wF_ZGr_RPgRjjA,500
 hunterMakesPy/theTypes.py,sha256=C2d0uLn1VIx6_2CK41it3IP7iplSQqe51tzWc-RT320,306
 hunterMakesPy/tests/__init__.py,sha256=C_FzfKDi_VrGVxlenWHyOYtKShAKlt3KW14jeRx1mQI,224
-hunterMakesPy/tests/conftest.py,sha256=K-XAGvYp6CZVCox5G5DvFA9Qk7X-oBl1BccmOXVn0BI,1645
+hunterMakesPy/tests/conftest.py,sha256=NZQPRiwvGhP16hJ6WGGm9eKLxfQArYV8E9X12YzSpP0,2827
 hunterMakesPy/tests/test_coping.py,sha256=mH89TUAL6fJanBLlhdVlCNNQqm5OpdcQMP_p5W2JJwo,9860
 hunterMakesPy/tests/test_dataStructures.py,sha256=O4aqzSKg7KfWWVhIewOH0Y8Zj28PbFCb4XX3xhwuFQA,16605
-hunterMakesPy/tests/test_filesystemToolkit.py,sha256=HmRKHXAvGz12YAI-FT9tz42CDNK6p5NcZEVPLzdfetE,2460
+hunterMakesPy/tests/test_filesystemToolkit.py,sha256=q2voXjCbQPIT8l8VF9iuWX1Bs2ZieABItWoVkITj_fo,8841
 hunterMakesPy/tests/test_parseParameters.py,sha256=80npsoWcCackjxvoW2dMXMpHeale7fuRXyXp78MibLs,14037
-huntermakespy-0.2.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-huntermakespy-0.2.0.dist-info/METADATA,sha256=FnWnf_rjZ_-uC3s1j4rUeLmOYc4B1s6j8TOJJcn3QlY,6631
-huntermakespy-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-huntermakespy-0.2.0.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
-huntermakespy-0.2.0.dist-info/RECORD,,
+huntermakespy-0.2.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+huntermakespy-0.2.2.dist-info/METADATA,sha256=s4xUkaMaL_EEx5S0V5YZdV4qyl_ql6dx1Ozgvhf6kRA,6547
+huntermakespy-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+huntermakespy-0.2.2.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
+huntermakespy-0.2.2.dist-info/RECORD,,