hunterMakesPy 0.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

hunterMakesPy/tests/test_parseParameters.py

@@ -1,3 +1,11 @@
+"""Tests for parameter parsing and validation utilities.
+
+(AI generated docstring)
+
+This module provides test suites for concurrency limits, integer initialization,
+and string-based boolean parsing.
+
+"""
 # pyright: standard
 from collections.abc import Callable, Iterable, Iterator
 from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
@@ -66,7 +74,7 @@ def PytestFor_defineConcurrencyLimit(callableToTest: Callable[..., int] = define
 		testCases: dict[float, int] = {
 			0.5: cpuCount // 2,
 			0.25: cpuCount // 4,
-			0.75: int(cpuCount * 0.75)
+			0.75: int(cpuCount * 0.75),
 		}
 		for limit, expected in testCases.items():
 			assert callableToTest(limit=limit, cpuTotal=cpuCount) == expected
@@ -114,7 +122,7 @@ def PytestFor_defineConcurrencyLimit(callableToTest: Callable[..., int] = define
 		('testStringNumbers', testStringNumbers)
 	]
 
-def PytestFor_intInnit(callableToTest: Callable[[Iterable[int], str | None, type[Any] | None], list[int]] = intInnit) -> list[tuple[str, Callable[[], None]]]:
+def PytestFor_intInnit(callableToTest: Callable[[Iterable[Any], str | None, type[Any] | None], list[int]] = intInnit) -> list[tuple[str, Callable[[], None]]]:
 	"""Return a list of test functions to validate integer initialization behavior.
 
 	This function provides a comprehensive test suite for validating integer parsing
@@ -222,7 +230,7 @@ def PytestFor_intInnit(callableToTest: Callable[[Iterable[int], str | None, type
 			def __iter__(self) -> Iterator[int]:
 				self.append(89)
 				return super().__iter__()
-		with pytest.raises(RuntimeError, match=".*modified during iteration.*"):
+		with pytest.raises(RuntimeError, match=r".*modified during iteration.*"):
 			callableToTest(MutableList([13, 21, 34]), 'test', None)
 
 	def testHandlesComplexIntegers() -> None:
@@ -252,7 +260,7 @@ def PytestFor_intInnit(callableToTest: Callable[[Iterable[int], str | None, type
 		('testRejectsInvalidComplex', testRejectsInvalidComplex)
 	]
 
-def PytestFor_oopsieKwargsie(callableToTest: Callable[[str], bool | None | str] = oopsieKwargsie) -> list[tuple[str, Callable[[], None]]]:
+def PytestFor_oopsieKwargsie(callableToTest: Callable[[Any], object] = oopsieKwargsie) -> list[tuple[str, Callable[[], None]]]:
 	"""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
@@ -311,13 +319,13 @@ def PytestFor_oopsieKwargsie(callableToTest: Callable[[str], bool | None | str]
 	def testHandlesNonStringObjects() -> None:
 		class NeverGonnaStringIt:
 			def __str__(self) -> NoReturn:
-				message = "Cannot be stringified"
+				message: str = "Cannot be stringified"
 				raise TypeError(message)
 
 		assert callableToTest(123) == "123"
 
-		neverGonnaStringIt = NeverGonnaStringIt()
-		result = callableToTest(neverGonnaStringIt)
+		neverGonnaStringIt: NeverGonnaStringIt = NeverGonnaStringIt()
+		result: object = callableToTest(neverGonnaStringIt)
 		assert result is neverGonnaStringIt
 
 	return [
@@ -330,12 +338,60 @@ def PytestFor_oopsieKwargsie(callableToTest: Callable[[str], bool | None | str]
 
 @pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_defineConcurrencyLimit())
 def testConcurrencyLimit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	"""Execute generated tests for concurrency limit definitions.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	nameOfTest : str
+		Name of the test case.
+	aPytest : Callable[..., Any]
+		The callable test function to execute.
+	*arguments : Any
+		Positional arguments for the test function.
+	**keywordArguments : Any
+		Keyword arguments for the test function.
+
+	"""
 	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:
+	"""Execute generated tests for integer initialization.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	nameOfTest : str
+		Name of the test case.
+	aPytest : Callable[..., Any]
+		The callable test function to execute.
+	*arguments : Any
+		Positional arguments for the test function.
+	**keywordArguments : Any
+		Keyword arguments for the test function.
+
+	"""
 	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:
+	"""Execute generated tests for boolean string parsing.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	nameOfTest : str
+		Name of the test case.
+	aPytest : Callable[..., Any]
+		The callable test function to execute.
+	*arguments : Any
+		Positional arguments for the test function.
+	**keywordArguments : Any
+		Keyword arguments for the test function.
+
+	"""
 	aPytest(*arguments, **keywordArguments)

hunterMakesPy/tests/test_theTypes.py

@@ -0,0 +1,359 @@
+"""Tests for `Ordinals` ordering behaviors.
+
+(AI generated docstring)
+
+This module validates comparison semantics and sorting consistency across built-in and custom comparables using `pytest`.
+
+"""
+from dataclasses import dataclass
+from hunterMakesPy import CallableFunction, Ordinals
+from hunterMakesPy.tests.conftest import uniformTestFailureMessage
+from typing import Self, TYPE_CHECKING, TypeVar
+import functools
+import inspect
+import pytest
+
+if TYPE_CHECKING:
+	from collections.abc import Callable
+
+小于 = TypeVar('小于', bound=Ordinals)
+"""Type variable bound to `Ordinals`.
+
+(AI generated docstring)
+
+"""
+
+def between(floor: 小于, ceiling: 小于, comparand: 小于) -> bool:
+	"""Return whether `comparand` lies between `floor` and `ceiling` inclusive.
+
+	Parameters
+	----------
+	floor : 小于
+		Lower bound for `comparand`.
+	ceiling : 小于
+		Upper bound for `comparand`.
+	comparand : 小于
+		Value compared against `floor` and `ceiling`.
+
+	Returns
+	-------
+	isBetween : bool
+		Whether `comparand` is within the inclusive bounds.
+
+	"""
+	return floor <= comparand <= ceiling
+
+@dataclass(frozen=True, slots=True)
+class ComparableCardinal:
+	"""Comparable wrapper for an `int` value.
+
+	(AI generated docstring)
+
+	Attributes
+	----------
+	value : int
+		Integer used for ordering comparisons.
+
+	"""
+
+	value: int
+	"""Integer used for ordering comparisons.
+
+	(AI generated docstring)
+
+	"""
+
+	def __le__(self: Self, other: Self, /) -> bool:
+		"""Return whether `self` is less than or equal to `other`.
+
+		(AI generated docstring)
+
+		Parameters
+		----------
+		self : Self
+			Instance compared against `other`.
+		other : Self
+			Instance compared against `self`.
+
+		Returns
+		-------
+		isLessThanOrEqual : bool
+			Whether `self` is ordered before or equal to `other`.
+
+		"""
+		return self.value <= other.value
+
+	def __lt__(self: Self, other: Self, /) -> bool:
+		"""Return whether `self` is strictly less than `other`.
+
+		(AI generated docstring)
+
+		Parameters
+		----------
+		self : Self
+			Instance compared against `other`.
+		other : Self
+			Instance compared against `self`.
+
+		Returns
+		-------
+		isLessThan : bool
+			Whether `self` is ordered before `other`.
+
+		"""
+		return self.value < other.value
+
+@pytest.mark.parametrize(
+	'floor, ceiling, comparand, expected'
+	, [ (13, 34, 21, True) , (227, 695, 88, False) ]
+)
+def testOrdinalsBetweenWorksForInt(floor: int, ceiling: int, comparand: int, expected: bool) -> None:
+	"""Verify `between` handles `int` operands.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	floor : int
+		Lower bound for `comparand`.
+	ceiling : int
+		Upper bound for `comparand`.
+	comparand : int
+		Value of `comparand` compared against the bounds.
+	expected : bool
+		Expected outcome from `between`.
+
+	Returns
+	-------
+	unusedReturnValue : None
+		Returns `None`.
+
+	"""
+	actual: bool = between(floor, ceiling, comparand)
+	assert actual == expected, uniformTestFailureMessage( expected , actual , 'between' , floor , ceiling , comparand )
+
+@pytest.mark.parametrize(
+	'values, expected'
+	, [ ([21, 13, 34, 8], [8, 13, 21, 34]) ]
+)
+def testOrdinalsSortingWorksForInt(values: list[int], expected: list[int]) -> None:
+	"""Verify sorting uses ordinal ordering for `int` values.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	values : list[int]
+		Input `values` to sort.
+	expected : list[int]
+		Expected sorted output for `values`.
+
+	Returns
+	-------
+	unusedReturnValue : None
+		Returns `None`.
+
+	"""
+	actual: list[int] = sorted(values)
+	assert actual == expected, uniformTestFailureMessage( expected , actual , 'sorted' , values )
+
+@pytest.mark.parametrize(
+	'floor, ceiling, comparand, expected'
+	, [ ('fibonacci', 'prime', 'omega', True) , ('fibonacci', 'prime', 'tango', False) ]
+)
+def testOrdinalsBetweenWorksForStr(floor: str, ceiling: str, comparand: str, expected: bool) -> None:
+	"""Verify `between` handles `str` operands.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	floor : str
+		Lower bound for `comparand`.
+	ceiling : str
+		Upper bound for `comparand`.
+	comparand : str
+		Value of `comparand` compared against the bounds.
+	expected : bool
+		Expected outcome from `between`.
+
+	Returns
+	-------
+	unusedReturnValue : None
+		Returns `None`.
+
+	"""
+	actual: bool = between(floor, ceiling, comparand)
+	assert actual == expected, uniformTestFailureMessage( expected , actual , 'between' , floor , ceiling , comparand )
+
+@pytest.mark.parametrize(
+	'values, expected'
+	, [ (['prime', 'fibonacci', 'omega'], ['fibonacci', 'omega', 'prime']) ]
+)
+def testOrdinalsSortingWorksForStr(values: list[str], expected: list[str]) -> None:
+	"""Verify sorting uses ordinal ordering for `str` values.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	values : list[str]
+		Input `values` to sort.
+	expected : list[str]
+		Expected sorted output for `values`.
+
+	Returns
+	-------
+	unusedReturnValue : None
+		Returns `None`.
+
+	"""
+	actual: list[str] = sorted(values)
+	assert actual == expected, uniformTestFailureMessage( expected , actual , 'sorted' , values )
+
+@pytest.mark.parametrize(
+	'floor, ceiling, comparand, expected'
+	, [ ((13, 17), (21, 2), (13, 19), True) , ((13, 17), (21, 2), (8, 34), False) ]
+)
+def testOrdinalsBetweenWorksForTuple(floor: tuple[int, int], ceiling: tuple[int, int], comparand: tuple[int, int], expected: bool) -> None:
+	"""Verify `between` handles `tuple[int, int]` operands.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	floor : tuple[int, int]
+		Lower bound for `comparand`.
+	ceiling : tuple[int, int]
+		Upper bound for `comparand`.
+	comparand : tuple[int, int]
+		Value of `comparand` compared against the bounds.
+	expected : bool
+		Expected outcome from `between`.
+
+	Returns
+	-------
+	unusedReturnValue : None
+		Returns `None`.
+
+	"""
+	actual: bool = between(floor, ceiling, comparand)
+	assert actual == expected, uniformTestFailureMessage( expected , actual , 'between' , floor , ceiling , comparand )
+
+@pytest.mark.parametrize( 'values, expected' , [ ( [(21, 2), (13, 19), (13, 17), (8, 34)] , [(8, 34), (13, 17), (13, 19), (21, 2)] ) ] )
+def testOrdinalsSortingWorksForTuple(values: list[tuple[int, int]], expected: list[tuple[int, int]]) -> None:
+	"""Verify sorting uses ordinal ordering for `tuple[int, int]` values.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	values : list[tuple[int, int]]
+		Input `values` to sort.
+	expected : list[tuple[int, int]]
+		Expected sorted output for `values`.
+
+	Returns
+	-------
+	unusedReturnValue : None
+		Returns `None`.
+
+	"""
+	actual: list[tuple[int, int]] = sorted(values)
+	assert actual == expected, uniformTestFailureMessage( expected , actual , 'sorted' , values )
+
+@pytest.mark.parametrize(
+	'floor, ceiling, comparand, expected'
+	, [
+		(ComparableCardinal(13), ComparableCardinal(34), ComparableCardinal(21), True)
+		, (ComparableCardinal(13), ComparableCardinal(34), ComparableCardinal(8), False)
+	]
+)
+def testOrdinalsBetweenWorksForCustomComparable( floor: ComparableCardinal, ceiling: ComparableCardinal, comparand: ComparableCardinal, expected: bool ) -> None:
+	"""Verify `between` handles `ComparableCardinal` operands.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	floor : ComparableCardinal
+		Lower `ComparableCardinal` bound for `comparand`.
+	ceiling : ComparableCardinal
+		Upper `ComparableCardinal` bound for `comparand`.
+	comparand : ComparableCardinal
+		Value of `comparand` compared against the bounds.
+	expected : bool
+		Expected outcome from `between`.
+
+	Returns
+	-------
+	unusedReturnValue : None
+		Returns `None`.
+
+	"""
+	actual: bool = between(floor, ceiling, comparand)
+	assert actual == expected, uniformTestFailureMessage( expected , actual , 'between' , floor , ceiling , comparand )
+
+@pytest.mark.parametrize( 'comparisonMethodName' , [ '__le__' , '__lt__' ] )
+def testOrdinalsComparisonMethodsAcceptOtherOperand(comparisonMethodName: str) -> None:
+	"""Validate `Ordinals` comparison method signatures.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	comparisonMethodName : str
+		Name of the `Ordinals` comparison method to inspect.
+
+	Returns
+	-------
+	unusedReturnValue : None
+		Returns `None`.
+
+	"""
+	comparisonMethod: Callable[[Ordinals, Ordinals], bool] = getattr(Ordinals, comparisonMethodName)
+	signature: inspect.Signature = inspect.signature(comparisonMethod)
+	listParameters: list[inspect.Parameter] = list(signature.parameters.values())
+
+	assert len(listParameters) == 2, uniformTestFailureMessage(
+		2 , len(listParameters) , 'Ordinals comparison parameter count' , comparisonMethodName , signature )
+
+	listKinds: list[inspect._ParameterKind] = [parameter.kind for parameter in listParameters]
+	expectedKinds: list[inspect._ParameterKind] = [inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_ONLY]
+	assert listKinds == expectedKinds, uniformTestFailureMessage(
+		expectedKinds , listKinds , 'Ordinals comparison parameter kinds' , comparisonMethodName , signature )
+
+	actualReturnAnnotation: object = signature.return_annotation
+	assert actualReturnAnnotation is bool, uniformTestFailureMessage(
+		bool , actualReturnAnnotation , 'Ordinals comparison return annotation' , comparisonMethodName , signature )
+
+def _plainFunction() -> None:
+	"""A plain function for testing."""
+
+@functools.wraps(_plainFunction)
+def _wrappedFunction() -> None:
+	"""A wrapped function for testing."""
+
+_lambdaFunction = lambda: None  # noqa: E731
+
+@pytest.mark.parametrize( 'candidate, expected' , [ (_wrappedFunction, True), (_plainFunction, False), (_lambdaFunction, False)] )
+def testCallableFunctionIdentifiesCompatibleObjects(candidate: object, expected: bool) -> None:
+	"""Verify `CallableFunction` protocol matching.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	candidate : object
+		The object to check against `CallableFunction`.
+	expected : bool
+		Expected result of `isinstance(candidate, CallableFunction)`.
+
+	Return
+	------
+	unusedReturnValue : None
+		Returns `None`.
+
+	"""
+	actual: bool = isinstance(candidate, CallableFunction)
+	assert actual == expected, uniformTestFailureMessage(expected, actual, 'isinstance', candidate)

hunterMakesPy/theTypes.py

@@ -1,21 +1,20 @@
 """I type, you type, we all `type` for `theTypes`."""
-from typing import Protocol, Self, TypeAlias
+from hunterMakesPy.Z0Z_CallableFunction import CallableFunction as CallableFunction
+from typing import Protocol, Self
 
-identifierDotAttribute: TypeAlias = str
+type identifierDotAttribute = str
 """`str` (***str***ing) representing a dotted attribute identifier.
 
 `TypeAlias` for a `str` `object` using dot notation to access an attribute, such as 'scipy.signal.windows'.
-
 """
 
 class Ordinals(Protocol):
 	"""Any Python `object` `type` that may be ordered before or after a comparable `object` `type` by comparison operators."""
 
-	def __le__(self, not_self_selfButSelfSelf_youKnow: Self, /) -> bool:
+	def __le__(self: Self, not_self_selfButSelfSelf_youKnow: Self, /) -> bool:
 		"""Comparison by "***l***ess than or ***e***qual to"."""
 		...
 
-	def __lt__(self, not_self_selfButSelfSelf_youKnow: Self, /) -> bool:
+	def __lt__(self: Self, otherSelfWhichIsNotAnOxymoron: Self, /) -> bool:
 		"""Comparison by "***l***ess ***t***han"."""
 		...
-

{huntermakespy-0.3.3.dist-info → huntermakespy-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.3.3
+Version: 0.4.0
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -19,7 +19,6 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 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.14
@@ -27,7 +26,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: autoflake

huntermakespy-0.4.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+hunterMakesPy/Z0Z_CallableFunction.py,sha256=MfRFZXc_OrkYKzCk5zt-s0I2VpagoZsYbigG7OFfC7g,2571
+hunterMakesPy/__init__.py,sha256=KOKYnqyIR752RG0KbdC1olOk_lDk9zDVQvJL_W6hJQU,1300
+hunterMakesPy/_theSSOT.py,sha256=x9Rdmw0qeAqgmlMFyFYRTRV5kEDYXcN4aBZ4KjlnKEU,170
+hunterMakesPy/coping.py,sha256=HqU5Qei-tK-yFZDmInHXhmEjmgvyd0XLoejN5HeQr9E,6033
+hunterMakesPy/dataStructures.py,sha256=GbFk5uJskkjL5WNCSJbgn7BKQVh0f792gZ4zgSod9H8,11934
+hunterMakesPy/filesystemToolkit.py,sha256=4zgXrDELBnS2UJ4sGPJVFyyrjDwfF0evnGIWssm--Jk,6809
+hunterMakesPy/parseParameters.py,sha256=k5sGBoCeVRK02lNze59xPb99UiXm2l-HXI5HQPcKHnY,11321
+hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hunterMakesPy/pytestForYourUse.py,sha256=wQe9e4ndiVpQQjm_VJFbo1WSRkmiF4Hx3RkCmw5jhcU,413
+hunterMakesPy/theTypes.py,sha256=HzUPPpR3qv8K_1rccjOpkpqmT3XLfrkF369t3HuE80s,808
+hunterMakesPy/tests/__init__.py,sha256=C_FzfKDi_VrGVxlenWHyOYtKShAKlt3KW14jeRx1mQI,224
+hunterMakesPy/tests/conftest.py,sha256=yX8RCaAnV7cDPk7G0EQsdCUhN3lWtcUzwe-EUjCdWsE,5108
+hunterMakesPy/tests/test_coping.py,sha256=2PE2CRqAvIAWAMCX_lkkRLjH9IXPtMDWOWIDQschcJ0,11412
+hunterMakesPy/tests/test_dataStructures.py,sha256=btLgXK5ksUntYToDFreXv0BMgr9XzH0aP0hgpPsPMBU,19310
+hunterMakesPy/tests/test_filesystemToolkit.py,sha256=obKbiruo8Vpwx7R-5cTQMJHxsQuXQrHRkWIEYOPcy_E,19491
+hunterMakesPy/tests/test_parseParameters.py,sha256=lRsAsAmIoNoSei0xlwek7Uu9ypaWiDFTYe4UnFG9MqU,14585
+hunterMakesPy/tests/test_theTypes.py,sha256=-1HrGD_CGyHIFu6-CsIZT1EZoYOE34GsKbi1QJaQwrM,10010
+huntermakespy-0.4.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+huntermakespy-0.4.0.dist-info/METADATA,sha256=JsLgBKkBChFfwMZFMhfAXsg0cNMwJy3dwLXT5mzxmhY,6268
+huntermakespy-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+huntermakespy-0.4.0.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
+huntermakespy-0.4.0.dist-info/RECORD,,

{huntermakespy-0.3.3.dist-info → huntermakespy-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

huntermakespy-0.3.3.dist-info/RECORD

@@ -1,20 +0,0 @@
-hunterMakesPy/__init__.py,sha256=bydhevjZG6_JT2q_v9rfozvjhXVqyyUGCovL6EwxlBk,1168
-hunterMakesPy/_theSSOT.py,sha256=x9Rdmw0qeAqgmlMFyFYRTRV5kEDYXcN4aBZ4KjlnKEU,170
-hunterMakesPy/coping.py,sha256=42a_1kB6zHeRpfbpPnjmhrgWTPvUtqE5W9z3tqu-K8w,6068
-hunterMakesPy/dataStructures.py,sha256=GbFk5uJskkjL5WNCSJbgn7BKQVh0f792gZ4zgSod9H8,11934
-hunterMakesPy/filesystemToolkit.py,sha256=4zgXrDELBnS2UJ4sGPJVFyyrjDwfF0evnGIWssm--Jk,6809
-hunterMakesPy/parseParameters.py,sha256=k5sGBoCeVRK02lNze59xPb99UiXm2l-HXI5HQPcKHnY,11321
-hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hunterMakesPy/pytestForYourUse.py,sha256=GiN1C1gTTM0ZunRPEMnrKlLQLMdH0wF_ZGr_RPgRjjA,500
-hunterMakesPy/theTypes.py,sha256=Ce2hGCsBgd_DaUVoWZ6Iq-Lp4qf6053orHq0o52ssgM,734
-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=WQlq98SllAPSUEjvIHZ9Az2pKNWeLNP4dnl3UyP9yuc,16004
-hunterMakesPy/tests/test_filesystemToolkit.py,sha256=_CoSMzstJwWZ_tkNyIqclOIIqTaY2tYfUIgxGFfC0Jk,15335
-hunterMakesPy/tests/test_parseParameters.py,sha256=UKf1hwhLtXYL96VVJNf8NpJOyzRLO204pd-9PdDjufA,13267
-huntermakespy-0.3.3.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-huntermakespy-0.3.3.dist-info/METADATA,sha256=VNrznpDWhCCoxUM0nAufsjImFAiVagnHgFbCPPXxnzQ,6319
-huntermakespy-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-huntermakespy-0.3.3.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
-huntermakespy-0.3.3.dist-info/RECORD,,