hunterMakesPy 0.3.3__py3-none-any.whl → 0.3.4__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,420 @@
+"""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 __future__ import annotations
+
+from dataclasses import dataclass
+from hunterMakesPy.tests.conftest import uniformTestFailureMessage
+from hunterMakesPy.theTypes import Ordinals
+from typing import Self, TYPE_CHECKING, TypeVar
+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)
+		, (13, 34, 8, 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
+	)

hunterMakesPy/theTypes.py

@@ -5,17 +5,15 @@ identifierDotAttribute: TypeAlias = 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.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.3.3
+Version: 0.3.4
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

huntermakespy-0.3.4.dist-info/RECORD

@@ -0,0 +1,21 @@
+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=wQe9e4ndiVpQQjm_VJFbo1WSRkmiF4Hx3RkCmw5jhcU,413
+hunterMakesPy/theTypes.py,sha256=uj5p0S2amTY-hhTIyQwDdvsLETiqTi8nI4-lScNtc38,741
+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=efd1i-43Bz1oZRJQJf2H8mWpFbCfYcuqjVWH3VrVqTE,9253
+huntermakespy-0.3.4.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+huntermakespy-0.3.4.dist-info/METADATA,sha256=ZPiwKZBsBYXXif2DggcOT0COaO646sUioEgmprbjiA4,6319
+huntermakespy-0.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+huntermakespy-0.3.4.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
+huntermakespy-0.3.4.dist-info/RECORD,,

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,,