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

{tests → hunterMakesPy/tests}/test_dataStructures.py

@@ -2,13 +2,17 @@
 from collections.abc import Callable, Iterable, Iterator
 from decimal import Decimal
 from fractions import Fraction
-from hunterMakesPy import autoDecodingRLE, stringItUp, updateExtendPolishDictionaryLists
+from hunterMakesPy import stringItUp, updateExtendPolishDictionaryLists
+from hunterMakesPy.tests.conftest import standardizedEqualTo
 from numpy.typing import NDArray
-from tests.conftest import standardizedEqualTo
 from typing import Any, Literal
 import datetime
 import numpy
 import pytest
+import sys
+
+if sys.version_info < (3, 14):
+	from hunterMakesPy import autoDecodingRLE
 
 class CustomIterable:
 	def __init__(self, items: Iterable[Any]) -> None: self.items = items
@@ -81,7 +85,7 @@ def testStringItUpErrorCases(description: Literal['Memory view'], value_scrapPil
 def testUpdateExtendPolishDictionaryLists(description: str, value_dictionaryLists: dict[str, Any], keywordArguments: dict[str, Any], expected: dict[str, Any] | type[TypeError]) -> None:
 	standardizedEqualTo(expected, updateExtendPolishDictionaryLists, *value_dictionaryLists, **keywordArguments)
 # ruff: noqa: ERA001
-# NOTE one line of code with `standardizedEqualTo` replaced the following ten lines of code.
+# NOTE one line of code with `standardizedEqualTo` replaced the following ten lines of code. Use `standardizedEqualTo`.
 	# if isinstance(expected, type) and issubclass(expected, Exception):
 	#	 with pytest.raises(expected):
 	#		 updateExtendPolishDictionaryLists(*value_dictionaryLists, **keywordArguments)
@@ -94,26 +98,28 @@ def testUpdateExtendPolishDictionaryLists(description: str, value_dictionaryList
 	#		 assert result == expected
 
 # ruff: noqa: RUF005
-@pytest.mark.parametrize("description,value_arrayTarget,expected", [
-	("One range", numpy.array(list(range(50,60))), "[*range(50,60)]"),
-	("Value, range", numpy.array([123]+list(range(71,81))), "[123,*range(71,81)]"),
-	("range, value", numpy.array(list(range(91,97))+[101]), "[*range(91,97),101]"),
-	("Value, range, value", numpy.array([151]+list(range(163,171))+[181]), "[151,*range(163,171),181]"),
-	("Repeat values", numpy.array([191, 191, 191]), "[191]*3"),
-	("Value with repeat", numpy.array([211, 223, 223, 223]), "[211]+[223]*3"),
-	("Range with repeat", numpy.array(list(range(251,257))+[271, 271, 271]), "[*range(251,257)]+[271]*3"),
-	("Value, range, repeat", numpy.array([281]+list(range(291,297))+[307, 307]), "[281,*range(291,297)]+[307]*2"),
-	("repeat, value", numpy.array([313, 313, 313, 331, 331, 349]), "[313]*3+[331]*2+[349]"),
-	("repeat, range", numpy.array([373, 373, 373]+list(range(383,389))), "[373]*3+[*range(383,389)]"),
-	("repeat, range, value", numpy.array(7*[401]+list(range(409,415))+[421]), "[401]*7+[*range(409,415),421]"),
-	("Repeated primes", numpy.array([431, 431, 431, 443, 443, 457]), "[431]*3+[443]*2+[457]"),
-	("Two Ranges", numpy.array(list(range(461,471))+list(range(479,487))), "[*range(461,471),*range(479,487)]"),
-	("2D array primes", numpy.array([[491, 499, 503], [509, 521, 523]]), "[[491,499,503],[509,521,523]]"),
-	("3D array primes", numpy.array([[[541, 547], [557, 563]], [[569, 571], [577, 587]]]), "[[[541,547],[557,563]],[[569,571],[577,587]]]"),
-], ids=lambda x: x if isinstance(x, str) else "")
-def testAutoDecodingRLE(description: str, value_arrayTarget: NDArray[numpy.integer[Any]], expected: str) -> None:
-	"""Test autoDecodingRLE with various input arrays."""
-	standardizedEqualTo(expected, autoDecodingRLE, value_arrayTarget)
+
+if sys.version_info < (3, 14):
+	@pytest.mark.parametrize("description,value_arrayTarget,expected", [
+		("One range", numpy.array(list(range(50,60))), "[*range(50,60)]"),
+		("Value, range", numpy.array([123]+list(range(71,81))), "[123,*range(71,81)]"),
+		("range, value", numpy.array(list(range(91,97))+[101]), "[*range(91,97),101]"),
+		("Value, range, value", numpy.array([151]+list(range(163,171))+[181]), "[151,*range(163,171),181]"),
+		("Repeat values", numpy.array([191, 191, 191]), "[191]*3"),
+		("Value with repeat", numpy.array([211, 223, 223, 223]), "[211]+[223]*3"),
+		("Range with repeat", numpy.array(list(range(251,257))+[271, 271, 271]), "[*range(251,257)]+[271]*3"),
+		("Value, range, repeat", numpy.array([281]+list(range(291,297))+[307, 307]), "[281,*range(291,297)]+[307]*2"),
+		("repeat, value", numpy.array([313, 313, 313, 331, 331, 349]), "[313]*3+[331]*2+[349]"),
+		("repeat, range", numpy.array([373, 373, 373]+list(range(383,389))), "[373]*3+[*range(383,389)]"),
+		("repeat, range, value", numpy.array(7*[401]+list(range(409,415))+[421]), "[401]*7+[*range(409,415),421]"),
+		("Repeated primes", numpy.array([431, 431, 431, 443, 443, 457]), "[431]*3+[443]*2+[457]"),
+		("Two Ranges", numpy.array(list(range(461,471))+list(range(479,487))), "[*range(461,471),*range(479,487)]"),
+		("2D array primes", numpy.array([[491, 499, 503], [509, 521, 523]]), "[[491,499,503],[509,521,523]]"),
+		("3D array primes", numpy.array([[[541, 547], [557, 563]], [[569, 571], [577, 587]]]), "[[[541,547],[557,563]],[[569,571],[577,587]]]"),
+	], ids=lambda x: x if isinstance(x, str) else "")
+	def testAutoDecodingRLE(description: str, value_arrayTarget: NDArray[numpy.integer[Any]], expected: str) -> None:
+		"""Test autoDecodingRLE with various input arrays."""
+		standardizedEqualTo(expected, autoDecodingRLE, value_arrayTarget)
 
 # Helper functions for generating RLE test data
 def generateCartesianMapping(dimensions: tuple[int, int], formula: Callable[[int, int], int]) -> NDArray[Any]:
@@ -222,98 +228,98 @@ def generateAlternatingColumns(dimensions: tuple[int, int], blockSize: int = 1)
 
 	return generateCartesianMapping(dimensions, columnFormula)
 
-# Updated test cases for autoDecodingRLE with more realistic data
-@pytest.mark.parametrize("description,value_arrayTarget", [
-	# Basic test cases with simple patterns
-	("Simple range", numpy.array(list(range(50,60)))),
-
-	# Chessboard patterns
-	("Small chessboard", generateChessboard((8, 8))),
-
-	# Alternating columns - creates patterns with good RLE opportunities
-	("Alternating columns", generateAlternatingColumns((5, 20), 2)),
-
-	# Step pattern - creates horizontal runs
-	("Step pattern", generateStepPattern((6, 30), 3)),
-
-	# Repeating zones - creates horizontal bands
-	("Repeating zones", generateRepeatingZones((40, 40), 8)),
-
-	# Tile pattern - creates complex repeating regions
-	("Tile pattern", generateTilePattern((15, 15), 5)),
-
-	# Signed quadratic function - includes negative values
-	("Signed quadratic", generateSignedQuadraticFunction((10, 10))),
-
-	# Prime modulo matrix - periodic patterns
-	("Prime modulo", generatePrimeModuloMatrix((12, 12), 7)),
-
-	# Wave pattern - smooth gradients
-	("Wave pattern", generateWavePattern((20, 20))),
-
-	# Spiral pattern - complex pattern with good RLE potential
-	("Spiral pattern", generateSpiralPattern((15, 15), 2)),
-], ids=lambda x: x if isinstance(x, str) else "")
-def testAutoDecodingRLEWithRealisticData(description: str, value_arrayTarget: NDArray[numpy.integer[Any]]) -> None:
-	"""Test autoDecodingRLE with more realistic data patterns."""
-	# Here we test the function behavior rather than expected string output
-	resultRLE = autoDecodingRLE(value_arrayTarget)
-
-	# Test that the result is a valid string
-	assert isinstance(resultRLE, str)
-
-	# Test that the result contains the expected syntax elements
-	assert "[" in resultRLE, f"Result should contain list syntax: {resultRLE}"
-	assert "]" in resultRLE, f"Result should contain list syntax: {resultRLE}"
-
-	# Check that the result is more compact than the raw string representation
-	rawStrLength = len(str(value_arrayTarget.tolist()))
-	encodedLength = len(resultRLE)
-	assert encodedLength <= rawStrLength, f"Encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"
-
-@pytest.mark.parametrize("description,addSpaces", [
-	("With spaces", True),
-	("Without spaces", False),
-], ids=lambda x: x if isinstance(x, str) else "")
-def testAutoDecodingRLEWithSpaces(description: str, addSpaces: bool) -> None:
-	"""Test that the addSpaces parameter affects the internal comparison logic.
-
-	Note: addSpaces doesn't directly change the output format, it just changes
-	the comparison when measuring the length of the string representation.
-	The feature exists because `ast` inserts spaces in its string representation.
-	"""
-	# Create a pattern that has repeated sequences to trigger the RLE logic
-	arrayTarget = generateRepeatingZones((10, 10), 2)
-
-	# Test both configurations
-	resultWithSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=addSpaces)
-	resultNoSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=False)
-
-	# When addSpaces=True, the internal length comparisons change
-	# but the actual output format doesn't necessarily differ
-	# Just verify the function runs without errors in both cases
-	assert isinstance(resultWithSpacesFlag, str)
-	assert isinstance(resultNoSpacesFlag, str)
-
-def testAutoDecodingRLELargeCartesianMapping() -> None:
-	"""Test autoDecodingRLE with a large (100x100) cartesian mapping."""
-	dimensions = (100, 100)
-
-	# Generate a large cartesian mapping with a complex pattern
-	def complexFormula(x: int, y: int) -> int:
-		return ((x * 17) % 11 + (y * 13) % 7) % 10
-
-	arrayMapping = generateCartesianMapping(dimensions, complexFormula)
-
-	# Verify the function works with large arrays
-	resultRLE = autoDecodingRLE(arrayMapping)
-
-	# The result should be a valid string representation
-	assert isinstance(resultRLE, str)
-	assert "[" in resultRLE
-	assert "]" in resultRLE
-
-	# The RLE encoding should be more compact than the raw representation
-	rawStrLength = len(str(arrayMapping.tolist()))
-	encodedLength = len(resultRLE)
-	assert encodedLength <= rawStrLength, f"RLE encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"
+if sys.version_info < (3, 14):
+	@pytest.mark.parametrize("description,value_arrayTarget", [
+		# Basic test cases with simple patterns
+		("Simple range", numpy.array(list(range(50,60)))),
+
+		# Chessboard patterns
+		("Small chessboard", generateChessboard((8, 8))),
+
+		# Alternating columns - creates patterns with good RLE opportunities
+		("Alternating columns", generateAlternatingColumns((5, 20), 2)),
+
+		# Step pattern - creates horizontal runs
+		("Step pattern", generateStepPattern((6, 30), 3)),
+
+		# Repeating zones - creates horizontal bands
+		("Repeating zones", generateRepeatingZones((40, 40), 8)),
+
+		# Tile pattern - creates complex repeating regions
+		("Tile pattern", generateTilePattern((15, 15), 5)),
+
+		# Signed quadratic function - includes negative values
+		("Signed quadratic", generateSignedQuadraticFunction((10, 10))),
+
+		# Prime modulo matrix - periodic patterns
+		("Prime modulo", generatePrimeModuloMatrix((12, 12), 7)),
+
+		# Wave pattern - smooth gradients
+		("Wave pattern", generateWavePattern((20, 20))),
+
+		# Spiral pattern - complex pattern with good RLE potential
+		("Spiral pattern", generateSpiralPattern((15, 15), 2)),
+	], ids=lambda x: x if isinstance(x, str) else "")
+	def testAutoDecodingRLEWithRealisticData(description: str, value_arrayTarget: NDArray[numpy.integer[Any]]) -> None:
+		"""Test autoDecodingRLE with more realistic data patterns."""
+		# Here we test the function behavior rather than expected string output
+		resultRLE = autoDecodingRLE(value_arrayTarget)
+
+		# Test that the result is a valid string
+		assert isinstance(resultRLE, str)
+
+		# Test that the result contains the expected syntax elements
+		assert "[" in resultRLE, f"Result should contain list syntax: {resultRLE}"
+		assert "]" in resultRLE, f"Result should contain list syntax: {resultRLE}"
+
+		# Check that the result is more compact than the raw string representation
+		rawStrLength = len(str(value_arrayTarget.tolist()))
+		encodedLength = len(resultRLE)
+		assert encodedLength <= rawStrLength, f"Encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"
+
+	@pytest.mark.parametrize("description,addSpaces", [
+		("With spaces", True),
+		("Without spaces", False),
+	], ids=lambda x: x if isinstance(x, str) else "")
+	def testAutoDecodingRLEWithSpaces(description: str, addSpaces: bool) -> None:
+		"""Test that the addSpaces parameter affects the internal comparison logic.
+
+		Note: addSpaces doesn't directly change the output format, it just changes
+		the comparison when measuring the length of the string representation.
+		The feature exists because `ast` inserts spaces in its string representation.
+		"""
+		# Create a pattern that has repeated sequences to trigger the RLE logic
+		arrayTarget = generateRepeatingZones((10, 10), 2)
+
+		# Test both configurations
+		resultWithSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=addSpaces)
+		resultNoSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=False)
+
+		# When addSpaces=True, the internal length comparisons change
+		# but the actual output format doesn't necessarily differ
+		# Just verify the function runs without errors in both cases
+		assert isinstance(resultWithSpacesFlag, str)
+		assert isinstance(resultNoSpacesFlag, str)
+
+	def testAutoDecodingRLELargeCartesianMapping() -> None:
+		"""Test autoDecodingRLE with a large (100x100) cartesian mapping."""
+		dimensions = (100, 100)
+
+		# Generate a large cartesian mapping with a complex pattern
+		def complexFormula(x: int, y: int) -> int:
+			return ((x * 17) % 11 + (y * 13) % 7) % 10
+
+		arrayMapping = generateCartesianMapping(dimensions, complexFormula)
+
+		# Verify the function works with large arrays
+		resultRLE = autoDecodingRLE(arrayMapping)
+
+		# The result should be a valid string representation
+		assert isinstance(resultRLE, str)
+		assert "[" in resultRLE
+		assert "]" in resultRLE
+
+		# The RLE encoding should be more compact than the raw representation
+		rawStrLength = len(str(arrayMapping.tolist()))
+		encodedLength = len(resultRLE)
+		assert encodedLength <= rawStrLength, f"RLE encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"

hunterMakesPy/tests/test_filesystemToolkit.py

@@ -0,0 +1,263 @@
+# pyright: standard
+from hunterMakesPy import importLogicalPath2Identifier, importPathFilename2Identifier, makeDirsSafely, writeStringToHere
+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
+	)
+