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

hunterMakesPy/tests/test_parseParameters.py

@@ -0,0 +1,339 @@
+# pyright: standard
+from collections.abc import Callable, Iterable, Iterator
+from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
+from typing import Any, NoReturn, ParamSpec, TypeVar
+from unittest.mock import Mock, patch
+import pytest
+
+parameters = ParamSpec('parameters')
+returnType = TypeVar('returnType')
+
+def PytestFor_defineConcurrencyLimit(callableToTest: Callable[..., int] = defineConcurrencyLimit, cpuCount: int = 8) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
+	"""Return a list of test functions to validate concurrency limit behavior.
+
+	This function provides a comprehensive test suite for validating concurrency limit parsing
+	and computation, checking both valid and invalid input scenarios.
+
+	Parameters
+	----------
+	callableToTest : Callable[[bool | float | int | None, int], int] = defineConcurrencyLimit
+		The function to test, which should accept various input types and return an integer
+		representing the concurrency limit.
+	cpuCount : int = 8
+		The number of CPUs to simulate in the test environment.
+
+	Returns
+	-------
+	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
+		A list of tuples, each containing a string describing the test case and a callable
+		test function that implements the test case.
+
+	Examples
+	--------
+	Run each test on `hunterMakesPy.defineConcurrencyLimit`:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_defineConcurrencyLimit
+
+	listOfTests = PytestFor_defineConcurrencyLimit()
+	for nameOfTest, callablePytest in listOfTests:
+		callablePytest()
+	```
+
+	Or, run each test on your function that has a compatible signature:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_defineConcurrencyLimit
+	from packageLocal import functionLocal
+
+	@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit(callableToTest=functionLocal))
+	def test_functionLocal(nameOfTest, callablePytest):
+		callablePytest()
+	```
+
+	"""
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testDefaults(_mockCpu: Mock) -> None:
+		listOfParameters: list[bool | int | None] = [None, False, 0]
+		for limitParameter in listOfParameters:
+			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) == cpuCount
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testDirectIntegers(_mockCpu: Mock) -> None:
+		for limitParameter in [1, 4, 16]:
+			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) == limitParameter
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testFractionalFloats(_mockCpu: Mock) -> None:
+		testCases: dict[float, int] = {
+			0.5: cpuCount // 2,
+			0.25: cpuCount // 4,
+			0.75: int(cpuCount * 0.75)
+		}
+		for limit, expected in testCases.items():
+			assert callableToTest(limit=limit, cpuTotal=cpuCount) == expected
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testMinimumOne(_mockCpu: Mock) -> None:
+		listOfParameters: list[float | int] = [-10, -0.99, 0.1]
+		for limitParameter in listOfParameters:
+			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) >= 1
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testBooleanTrue(_mockCpu: Mock) -> None:
+		assert callableToTest(limit=True, cpuTotal=cpuCount) == 1
+		assert callableToTest(limit='True', cpuTotal=cpuCount) == 1  # pyright: ignore[reportArgumentType]
+		assert callableToTest(limit='TRUE', cpuTotal=cpuCount) == 1 # pyright: ignore[reportArgumentType]
+		assert callableToTest(limit=' true ', cpuTotal=cpuCount) == 1 # pyright: ignore[reportArgumentType]
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testInvalidStrings(_mockCpu: Mock) -> None:
+		for stringInput in ["invalid", "True but not quite", "None of the above"]:
+			with pytest.raises(ValueError, match="must be a number, `True`, `False`, or `None`"):
+				callableToTest(limit=stringInput, cpuTotal=cpuCount) # pyright: ignore[reportArgumentType]
+
+	@patch('multiprocessing.cpu_count', return_value=cpuCount)
+	def testStringNumbers(_mockCpu: Mock) -> None:
+		testCases: list[tuple[str, int]] = [
+			("1.51", 2),
+			("-2.51", 5),
+			("4", 4),
+			("0.5", 4),
+			("-0.25", 6),
+		]
+		for stringNumber, expectedLimit in testCases:
+			assert callableToTest(limit=stringNumber, cpuTotal=cpuCount) == expectedLimit # pyright: ignore[reportArgumentType]
+
+	return [
+		('testDefaults', testDefaults),
+		('testDirectIntegers', testDirectIntegers),
+		('testFractionalFloats', testFractionalFloats),
+		('testMinimumOne', testMinimumOne),
+		('testBooleanTrue', testBooleanTrue),
+		('testInvalidStrings', testInvalidStrings),
+		('testStringNumbers', testStringNumbers)
+	]
+
+def PytestFor_intInnit(callableToTest: Callable[[Iterable[int], str | None, type[Any] | None], list[int]] = intInnit) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
+	"""Return a list of test functions to validate integer initialization behavior.
+
+	This function provides a comprehensive test suite for validating integer parsing
+	and initialization, checking both valid and invalid input scenarios.
+
+	Parameters
+	----------
+	callableToTest : Callable[[Iterable[int], str | None, type[Any] | None], list[int]] = intInnit
+		The function to test. Should accept a sequence of integer-compatible values,
+		an optional parameter name string, and an optional parameter type.
+		Returns a list of validated integers.
+
+	Returns
+	-------
+	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
+		A list of tuples containing a string describing the test case and a callable
+		test function implementing the test case.
+
+	Examples
+	--------
+	Run tests on `hunterMakesPy.intInnit`:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_intInnit
+
+	listOfTests = PytestFor_intInnit()
+	for nameOfTest, callablePytest in listOfTests:
+		callablePytest()
+	```
+
+	Run tests on your compatible function:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_intInnit
+	from packageLocal import functionLocal
+
+	@pytest.mark.parametrize("nameOfTest,callablePytest",
+		PytestFor_intInnit(callableToTest=functionLocal))
+	def test_functionLocal(nameOfTest, callablePytest):
+		callablePytest()
+	```
+
+	"""
+	def testHandlesValidIntegers() -> None:
+		assert callableToTest([2, 3, 5, 8], 'test', None) == [2, 3, 5, 8]
+		assert callableToTest([13.0, 21.0, 34.0], 'test', None) == [13, 21, 34] # pyright: ignore[reportArgumentType]
+		assert callableToTest(['55', '89', '144'], 'test', None) == [55, 89, 144] # pyright: ignore[reportArgumentType]
+		assert callableToTest([' 233 ', '377', '-610'], 'test', None) == [233, 377, -610] # pyright: ignore[reportArgumentType]
+
+	def testRejectsNonWholeNumbers() -> None:
+		listInvalidNumbers: list[float] = [13.7, 21.5, 34.8, -55.9]
+		for invalidNumber in listInvalidNumbers:
+			with pytest.raises(ValueError):
+				callableToTest([invalidNumber], 'test', None) # pyright: ignore[reportArgumentType]
+
+	def testRejectsBooleans() -> None:
+		with pytest.raises(TypeError):
+			callableToTest([True, False], 'test', None)
+
+	def testRejectsInvalidStrings() -> None:
+		for invalidString in ['NW', '', ' ', 'SE.SW']:
+			with pytest.raises(ValueError):
+				callableToTest([invalidString], 'test', None) # pyright: ignore[reportArgumentType]
+
+	def testRejectsEmptyList() -> None:
+		with pytest.raises(ValueError):
+			callableToTest([], 'test', None)
+
+	def testHandlesMixedValidTypes() -> None:
+		assert callableToTest([13, '21', 34.0], 'test', None) == [13, 21, 34] # pyright: ignore[reportArgumentType]
+
+	def testHandlesBytes() -> None:
+		validCases: list[tuple[list[bytes], str, list[int]]] = [
+			([b'123'], '123', [123]),
+		]
+		for inputData, testName, expected in validCases:
+			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
+
+		extendedCases: list[tuple[list[bytes], str, list[int]]] = [
+			([b'123456789'], '123456789', [123456789]),
+		]
+		for inputData, testName, expected in extendedCases:
+			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
+
+		invalidCases: list[list[bytes]] = [[b'\x00']]
+		for inputData in invalidCases:
+			with pytest.raises(ValueError):
+				callableToTest(inputData, 'test', None) # pyright: ignore[reportArgumentType]
+
+	def testHandlesMemoryview() -> None:
+		validCases: list[tuple[list[memoryview], str, list[int]]] = [
+			([memoryview(b'123')], '123', [123]),
+		]
+		for inputData, testName, expected in validCases:
+			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
+
+		largeMemoryviewCase: list[memoryview] = [memoryview(b'9999999999')]
+		assert callableToTest(largeMemoryviewCase, 'test', None) == [9999999999] # pyright: ignore[reportArgumentType]
+
+		invalidMemoryviewCases: list[list[memoryview]] = [[memoryview(b'\x00')]]
+		for inputData in invalidMemoryviewCases:
+			with pytest.raises(ValueError):
+				callableToTest(inputData, 'test', None) # pyright: ignore[reportArgumentType]
+
+	def testRejectsMutableSequence() -> None:
+		class MutableList(list[int]):
+			def __iter__(self) -> Iterator[int]:
+				self.append(89)
+				return super().__iter__()
+		with pytest.raises(RuntimeError, match=".*modified during iteration.*"):
+			callableToTest(MutableList([13, 21, 34]), 'test', None)
+
+	def testHandlesComplexIntegers() -> None:
+		testCases: list[tuple[list[complex], list[int]]] = [
+			([13+0j], [13]),
+			([21+0j, 34+0j], [21, 34])
+		]
+		for inputData, expected in testCases:
+			assert callableToTest(inputData, 'test', None) == expected # pyright: ignore[reportArgumentType]
+
+	def testRejectsInvalidComplex() -> None:
+		for invalidComplex in [13+1j, 21+0.5j, 34.5+0j]:
+			with pytest.raises(ValueError):
+				callableToTest([invalidComplex], 'test', None) # pyright: ignore[reportArgumentType]
+
+	return [
+		('testHandlesValidIntegers', testHandlesValidIntegers),
+		('testRejectsNonWholeNumbers', testRejectsNonWholeNumbers),
+		('testRejectsBooleans', testRejectsBooleans),
+		('testRejectsInvalidStrings', testRejectsInvalidStrings),
+		('testRejectsEmptyList', testRejectsEmptyList),
+		('testHandlesMixedValidTypes', testHandlesMixedValidTypes),
+		('testHandlesBytes', testHandlesBytes),
+		('testHandlesMemoryview', testHandlesMemoryview),
+		('testRejectsMutableSequence', testRejectsMutableSequence),
+		('testHandlesComplexIntegers', testHandlesComplexIntegers),
+		('testRejectsInvalidComplex', testRejectsInvalidComplex)
+	]
+
+def PytestFor_oopsieKwargsie(callableToTest: Callable[[str], bool | None | str] = oopsieKwargsie) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
+	"""Return a list of test functions to validate string-to-boolean/None conversion behavior.
+
+	This function provides a comprehensive test suite for validating string parsing and conversion
+	to boolean or None values, with fallback to the original string when appropriate.
+
+	Parameters
+	----------
+	callableToTest : Callable[[str], bool | None | str] = oopsieKwargsie
+		The function to test, which should accept a string and return either a boolean, None,
+		or the original input.
+
+	Returns
+	-------
+	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
+		A list of tuples, each containing a string describing the test case and a callable
+		test function that implements the test case.
+
+	Examples
+	--------
+	Run each test on `hunterMakesPy.oopsieKwargsie`:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_oopsieKwargsie
+
+	listOfTests = PytestFor_oopsieKwargsie()
+	for nameOfTest, callablePytest in listOfTests:
+		callablePytest()
+	```
+
+	Or, run each test on your function that has a compatible signature:
+	```python
+	from hunterMakesPy.pytestForYourUse import PytestFor_oopsieKwargsie
+	from packageLocal import functionLocal
+
+	@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_oopsieKwargsie(callableToTest=functionLocal))
+	def test_functionLocal(nameOfTest, callablePytest):
+		callablePytest()
+	```
+
+	"""
+	def testHandlesTrueVariants() -> None:
+		for variantTrue in ['True', 'TRUE', ' true ', 'TrUe']:
+			assert callableToTest(variantTrue) is True
+
+	def testHandlesFalseVariants() -> None:
+		for variantFalse in ['False', 'FALSE', ' false ', 'FaLsE']:
+			assert callableToTest(variantFalse) is False
+
+	def testHandlesNoneVariants() -> None:
+		for variantNone in ['None', 'NONE', ' none ', 'NoNe']:
+			assert callableToTest(variantNone) is None
+
+	def testReturnsOriginalString() -> None:
+		for stringInput in ['hello', '123', 'True story', 'False alarm']:
+			assert callableToTest(stringInput) == stringInput
+
+	def testHandlesNonStringObjects() -> None:
+		class NeverGonnaStringIt:
+			def __str__(self) -> NoReturn:
+				message = "Cannot be stringified"
+				raise TypeError(message)
+
+		assert callableToTest(123) == "123" # pyright: ignore[reportArgumentType]
+
+		neverGonnaStringIt = NeverGonnaStringIt()
+		result = callableToTest(neverGonnaStringIt) # pyright: ignore[reportArgumentType]
+		assert result is neverGonnaStringIt
+
+	return [
+		('testHandlesTrueVariants', testHandlesTrueVariants),
+		('testHandlesFalseVariants', testHandlesFalseVariants),
+		('testHandlesNoneVariants', testHandlesNoneVariants),
+		('testReturnsOriginalString', testReturnsOriginalString),
+		('testHandlesNonStringObjects', testHandlesNonStringObjects)
+	]
+
+@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_defineConcurrencyLimit())
+def testConcurrencyLimit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	aPytest(*arguments, **keywordArguments)
+
+@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_intInnit())
+def testIntInnit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	aPytest(*arguments, **keywordArguments)
+
+@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_oopsieKwargsie())
+def testOopsieKwargsie(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	aPytest(*arguments, **keywordArguments)

{huntermakespy-0.1.2.dist-info → huntermakespy-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.1.2
+Version: 0.2.1
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -22,6 +22,7 @@ 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.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
@@ -32,7 +33,7 @@ License-File: LICENSE
 Requires-Dist: charset_normalizer
 Requires-Dist: more_itertools
 Requires-Dist: numpy
-Requires-Dist: python_minifier
+Requires-Dist: python_minifier; python_version < "3.14"
 Provides-Extra: development
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"
@@ -73,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."
 )
 ```
 
@@ -82,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
@@ -102,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
@@ -123,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
@@ -145,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
@@ -157,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()
 ```

huntermakespy-0.2.1.dist-info/RECORD

@@ -0,0 +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=jd7H5UtrIrPiCYWcvNBNa6DAy-2Ewcf21-jbGXg_IVI,4702
+hunterMakesPy/parseParameters.py,sha256=DXpyATx7trGBg_8jlO5dXGfLcG8vg_lU3R1sq1rRFOQ,11644
+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=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=q2voXjCbQPIT8l8VF9iuWX1Bs2ZieABItWoVkITj_fo,8841
+hunterMakesPy/tests/test_parseParameters.py,sha256=80npsoWcCackjxvoW2dMXMpHeale7fuRXyXp78MibLs,14037
+huntermakespy-0.2.1.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+huntermakespy-0.2.1.dist-info/METADATA,sha256=U7mdPv2TiV-JgdBigReM9zxA1N9uZ0Nb93fmASS1-bk,6501
+huntermakespy-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+huntermakespy-0.2.1.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
+huntermakespy-0.2.1.dist-info/RECORD,,

{huntermakespy-0.1.2.dist-info → huntermakespy-0.2.1.dist-info}/top_level.txt

@@ -1,2 +1 @@
 hunterMakesPy
-tests

huntermakespy-0.1.2.dist-info/RECORD

@@ -1,20 +0,0 @@
-hunterMakesPy/__init__.py,sha256=4gIm--UJmlQEhbLCqpiVFM_JVbyfVpvFFAJyMNFHekk,1329
-hunterMakesPy/_theSSOT.py,sha256=lkLOG3oTIWNKD_ULX55chlUGNqCHgqVIrBvolvK1vbQ,153
-hunterMakesPy/coping.py,sha256=covqNFAwkF9gjafrlAvMdtCO8haFsESQBhO-7s68qSg,5581
-hunterMakesPy/dataStructures.py,sha256=znMEnboo2iNXZtQKdmruRrJDEoeTfqoH4-coUDM75g4,11218
-hunterMakesPy/filesystemToolkit.py,sha256=vDYS0Rc1aP7ETLXHKoO3TfOpuwJQFQW2ybwtJNiIIo4,4305
-hunterMakesPy/parseParameters.py,sha256=plrJ4xR1FQnQR9j-oeMAwB2H9r_8QD8OALnw0OH8Kt0,11947
-hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hunterMakesPy/pytestForYourUse.py,sha256=21BI8TXyinf8rMmS6dTsuRMBOOFTcyoG_gD__Gz_e7Q,13288
-hunterMakesPy/theTypes.py,sha256=C2d0uLn1VIx6_2CK41it3IP7iplSQqe51tzWc-RT320,306
-huntermakespy-0.1.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=MkNc4Ar6yYrnAok4t1NWsgyOYFDiGo1qwXHyp8ChJf4,1672
-tests/test_coping.py,sha256=MQl0fhdWX2YSFzzjWMThSm_ZSnglE3anSJO2b33typU,9846
-tests/test_dataStructures.py,sha256=VhM3VzG1l8l3Iz1q9sQjpNBQTWSrl4zWbnefsGTccos,16406
-tests/test_filesystemToolkit.py,sha256=jk6Ke0fW6dlHIVyvA1lh7o7_I7DVZr6uMO3s_i43isQ,2445
-tests/test_parseParameters.py,sha256=bHD-O-OyWWwPOx3zvS53pSNPDm3LbFS05N5JcfNCLG4,1137
-huntermakespy-0.1.2.dist-info/METADATA,sha256=b1Xr8jhpu8t-H3BTVQUcCww_gG8q5fcb1REz-8AQbY8,6555
-huntermakespy-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-huntermakespy-0.1.2.dist-info/top_level.txt,sha256=dUy7z3LNO6aqNjPD81tZjE5N9HO70a14Y9lAWjWC2gA,20
-huntermakespy-0.1.2.dist-info/RECORD,,

tests/test_filesystemToolkit.py

@@ -1,43 +0,0 @@
-# pyright: standard
-from hunterMakesPy import importLogicalPath2Identifier, importPathFilename2Identifier, makeDirsSafely, writeStringToHere
-from tests.conftest import uniformTestFailureMessage
-import io
-import math
-import os
-import pathlib
-import pytest
-
-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))

tests/test_parseParameters.py

@@ -1,21 +0,0 @@
-# pyright: standard
-from collections.abc import Callable
-from hunterMakesPy.pytestForYourUse import (
-	PytestFor_defineConcurrencyLimit, PytestFor_intInnit, PytestFor_oopsieKwargsie)
-from typing import ParamSpec, TypeVar
-import pytest
-
-parameters = ParamSpec('parameters')
-returnType = TypeVar('returnType')
-
-@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_defineConcurrencyLimit())
-def testConcurrencyLimit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
-	aPytest(*arguments, **keywordArguments)
-
-@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_intInnit())
-def testIntInnit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
-	aPytest(*arguments, **keywordArguments)
-
-@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_oopsieKwargsie())
-def testOopsieKwargsie(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
-	aPytest(*arguments, **keywordArguments)