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

hunterMakesPy/Z0Z_CallableFunction.py

@@ -0,0 +1,70 @@
+"""Protocols for callable functions with full type safety."""
+from collections.abc import Callable
+from types import CellType, CodeType, MethodType
+from typing import Any, overload, ParamSpec, Protocol, runtime_checkable, Self, TypeVar, TypeVarTuple
+import sys
+
+#======== Stolen, uh, I mean copied from typeshed:stdlib\_typeshed\__init__.pyi ========
+type AnnotationForm = Any
+
+if sys.version_info >= (3, 14):
+	from annotationlib import Format
+
+# NOTE These return annotations, which can be arbitrary objects
+	type AnnotateFunc = Callable[[Format], dict[str, AnnotationForm]]
+	type EvaluateFunc = Callable[[Format], AnnotationForm]
+#======== End stolen, uh, I mean copied from typeshed:stdlib\_typeshed\__init__.pyi ========
+
+@runtime_checkable
+class CallableFunction[**P, R](Protocol):
+	"""A Protocol representing callable functions with descriptor support.
+
+	Mimics types.FunctionType while being a drop-in replacement for `collections.abc.Callable`. Includes all standard function
+	attributes and the descriptor protocol for proper method binding.
+
+	Note: @runtime_checkable only validates attribute presence, not signatures.
+	"""
+
+# NOTE: The eehhhh, IDK... section
+	__doc__: str | None
+	__wrapped__: Any  # For functools.wraps support
+# NOTE: End eehhhh, IDK... section
+
+	@property
+	def __closure__(self) -> tuple[CellType, ...] | None:
+		"""Tuple of cells that contain bindings for the function's free variables."""
+		...
+	__code__: CodeType
+	__defaults__: tuple[Any, ...] | None
+	__dict__: dict[str, Any]
+	@property
+	def __globals__(self) -> dict[str, Any]:
+		"""The global namespace in which the function was defined."""
+		...
+	__name__: str
+	__qualname__: str
+	__annotations__: dict[str, AnnotationForm]
+	if sys.version_info >= (3, 14):
+		__annotate__: AnnotateFunc | None
+	__kwdefaults__: dict[str, Any] | None
+	@property
+	def __builtins__(self) -> dict[str, Any]:
+		"""The built-in namespace in which the function was defined."""
+		...
+	__type_params__: tuple[TypeVar | ParamSpec | TypeVarTuple, ...]
+	__module__: str
+
+	def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+		"""Execute the callable with the given arguments."""
+		...
+
+	@overload
+	def __get__(self, instance: None, owner: type, /) -> Self: ...
+	@overload
+	def __get__(self, instance: object, owner: type | None = None, /) -> MethodType: ...
+	def __get__(self, instance: object | None, owner: type | None = None) -> Self | MethodType:
+		"""Descriptor protocol for method binding.
+
+		Returns self when accessed on the class, or a bound MethodType when accessed on an instance.
+		"""
+		...

hunterMakesPy/__init__.py

@@ -8,15 +8,22 @@ This package provides:
 
 """
 
-from hunterMakesPy.theTypes import identifierDotAttribute as identifierDotAttribute, Ordinals as Ordinals
+# isort: split
+from hunterMakesPy.theTypes import (
+	CallableFunction as CallableFunction, identifierDotAttribute as identifierDotAttribute, Ordinals as Ordinals)
 
+# isort: split
 from hunterMakesPy.coping import PackageSettings as PackageSettings, raiseIfNone as raiseIfNone
 
+# isort: split
 from hunterMakesPy.parseParameters import defineConcurrencyLimit, intInnit, oopsieKwargsie
 
+# isort: split
 from hunterMakesPy.filesystemToolkit import (
 	importLogicalPath2Identifier, importPathFilename2Identifier, makeDirsSafely, writePython, writeStringToHere)
 
+# isort: split
 from hunterMakesPy.dataStructures import autoDecodingRLE, stringItUp, updateExtendPolishDictionaryLists
 
+# isort: split
 from hunterMakesPy._theSSOT import settingsPackage  # pyright: ignore[reportUnusedImport]

hunterMakesPy/coping.py

@@ -2,14 +2,12 @@
 from importlib.util import find_spec
 from pathlib import Path
 from tomllib import loads as tomllib_loads
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING
 import dataclasses
 
 if TYPE_CHECKING:
 	from importlib.machinery import ModuleSpec
 
-TypeSansNone = TypeVar('TypeSansNone')
-
 def getIdentifierPackagePACKAGING(identifierPackageFALLBACK: str) -> str:
 	"""Get package name from pyproject.toml or fallback to provided value."""
 	try:
@@ -85,7 +83,7 @@ class PackageSettings:
 		if self.pathPackage == Path() and self.identifierPackage:
 			self.pathPackage = getPathPackageINSTALLING(self.identifierPackage)
 
-def raiseIfNone(expression: TypeSansNone | None, errorMessage: str | None = None) -> TypeSansNone:
+def raiseIfNone[TypeSansNone](expression: TypeSansNone | None, errorMessage: str | None = None) -> TypeSansNone:
 	"""Convert the `expression` return annotation from '`cerPytainty | None`' to '`cerPytainty`' because `expression` cannot be `None`; `raise` an `Exception` if you're wrong.
 
 	The Python interpreter evaluates `expression` to a value: think of a function call or an attribute access. You can use

hunterMakesPy/tests/test_theTypes.py

@@ -5,13 +5,11 @@
 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 import CallableFunction, Ordinals
 from hunterMakesPy.tests.conftest import uniformTestFailureMessage
-from hunterMakesPy.theTypes import Ordinals
 from typing import Self, TYPE_CHECKING, TypeVar
+import functools
 import inspect
 import pytest
 
@@ -107,10 +105,7 @@ class ComparableCardinal:
 
 @pytest.mark.parametrize(
 	'floor, ceiling, comparand, expected'
-	, [
-		(13, 34, 21, True)
-		, (13, 34, 8, False)
-	]
+	, [ (13, 34, 21, True) , (227, 695, 88, False) ]
 )
 def testOrdinalsBetweenWorksForInt(floor: int, ceiling: int, comparand: int, expected: bool) -> None:
 	"""Verify `between` handles `int` operands.
@@ -135,20 +130,11 @@ def testOrdinalsBetweenWorksForInt(floor: int, ceiling: int, comparand: int, exp
 
 	"""
 	actual: bool = between(floor, ceiling, comparand)
-	assert actual == expected, uniformTestFailureMessage(
-		expected
-		, actual
-		, '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])
-	]
+	, [ ([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.
@@ -169,19 +155,11 @@ def testOrdinalsSortingWorksForInt(values: list[int], expected: list[int]) -> No
 
 	"""
 	actual: list[int] = sorted(values)
-	assert actual == expected, uniformTestFailureMessage(
-		expected
-		, actual
-		, '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)
-	]
+	, [ ('fibonacci', 'prime', 'omega', True) , ('fibonacci', 'prime', 'tango', False) ]
 )
 def testOrdinalsBetweenWorksForStr(floor: str, ceiling: str, comparand: str, expected: bool) -> None:
 	"""Verify `between` handles `str` operands.
@@ -206,20 +184,11 @@ def testOrdinalsBetweenWorksForStr(floor: str, ceiling: str, comparand: str, exp
 
 	"""
 	actual: bool = between(floor, ceiling, comparand)
-	assert actual == expected, uniformTestFailureMessage(
-		expected
-		, actual
-		, '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'])
-	]
+	, [ (['prime', 'fibonacci', 'omega'], ['fibonacci', 'omega', 'prime']) ]
 )
 def testOrdinalsSortingWorksForStr(values: list[str], expected: list[str]) -> None:
 	"""Verify sorting uses ordinal ordering for `str` values.
@@ -240,19 +209,11 @@ def testOrdinalsSortingWorksForStr(values: list[str], expected: list[str]) -> No
 
 	"""
 	actual: list[str] = sorted(values)
-	assert actual == expected, uniformTestFailureMessage(
-		expected
-		, actual
-		, '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)
-	]
+	, [ ((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.
@@ -277,24 +238,9 @@ def testOrdinalsBetweenWorksForTuple(floor: tuple[int, int], ceiling: tuple[int,
 
 	"""
 	actual: bool = between(floor, ceiling, comparand)
-	assert actual == expected, uniformTestFailureMessage(
-		expected
-		, actual
-		, '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)]
-		),
-	],
-)
+@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.
 
@@ -314,12 +260,7 @@ def testOrdinalsSortingWorksForTuple(values: list[tuple[int, int]], expected: li
 
 	"""
 	actual: list[tuple[int, int]] = sorted(values)
-	assert actual == expected, uniformTestFailureMessage(
-		expected
-		, actual
-		, 'sorted'
-		, values
-	)
+	assert actual == expected, uniformTestFailureMessage( expected , actual , 'sorted' , values )
 
 @pytest.mark.parametrize(
 	'floor, ceiling, comparand, expected'
@@ -328,12 +269,7 @@ def testOrdinalsSortingWorksForTuple(values: list[tuple[int, int]], expected: li
 		, (ComparableCardinal(13), ComparableCardinal(34), ComparableCardinal(8), False)
 	]
 )
-def testOrdinalsBetweenWorksForCustomComparable(
-	floor: ComparableCardinal,
-	ceiling: ComparableCardinal,
-	comparand: ComparableCardinal,
-	expected: bool,
-) -> None:
+def testOrdinalsBetweenWorksForCustomComparable( floor: ComparableCardinal, ceiling: ComparableCardinal, comparand: ComparableCardinal, expected: bool ) -> None:
 	"""Verify `between` handles `ComparableCardinal` operands.
 
 	(AI generated docstring)
@@ -356,22 +292,9 @@ def testOrdinalsBetweenWorksForCustomComparable(
 
 	"""
 	actual: bool = between(floor, ceiling, comparand)
-	assert actual == expected, uniformTestFailureMessage(
-		expected
-		, actual
-		, 'between'
-		, floor
-		, ceiling
-		, comparand
-	)
+	assert actual == expected, uniformTestFailureMessage( expected , actual , 'between' , floor , ceiling , comparand )
 
-@pytest.mark.parametrize(
-	'comparisonMethodName'
-	, [
-		'__le__'
-		, '__lt__'
-	]
-)
+@pytest.mark.parametrize( 'comparisonMethodName' , [ '__le__' , '__lt__' ] )
 def testOrdinalsComparisonMethodsAcceptOtherOperand(comparisonMethodName: str) -> None:
 	"""Validate `Ordinals` comparison method signatures.
 
@@ -393,28 +316,44 @@ def testOrdinalsComparisonMethodsAcceptOtherOperand(comparisonMethodName: str) -
 	listParameters: list[inspect.Parameter] = list(signature.parameters.values())
 
 	assert len(listParameters) == 2, uniformTestFailureMessage(
-		2
-		, len(listParameters)
-		, 'Ordinals comparison parameter count'
-		, comparisonMethodName
-		, signature
-	)
+		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
-	)
+		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
-	)
+		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,7 +1,8 @@
 """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'.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.3.4
+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.3.4.dist-info → huntermakespy-0.4.0.dist-info}/RECORD

@@ -1,21 +1,22 @@
-hunterMakesPy/__init__.py,sha256=bydhevjZG6_JT2q_v9rfozvjhXVqyyUGCovL6EwxlBk,1168
+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=42a_1kB6zHeRpfbpPnjmhrgWTPvUtqE5W9z3tqu-K8w,6068
+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=uj5p0S2amTY-hhTIyQwDdvsLETiqTi8nI4-lScNtc38,741
+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=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/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.4.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