hunterMakesPy 0.3.4__tar.gz → 0.4.0__tar.gz

{huntermakespy-0.3.4 → huntermakespy-0.4.0}/PKG-INFO

@@ -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.4.0/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-0.3.4 → huntermakespy-0.4.0}/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-0.3.4 → huntermakespy-0.4.0}/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-0.3.4 → huntermakespy-0.4.0}/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-0.3.4 → huntermakespy-0.4.0}/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 → huntermakespy-0.4.0}/hunterMakesPy.egg-info/PKG-INFO

@@ -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 → huntermakespy-0.4.0}/hunterMakesPy.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
+hunterMakesPy/Z0Z_CallableFunction.py
 hunterMakesPy/__init__.py
 hunterMakesPy/_theSSOT.py
 hunterMakesPy/coping.py

{huntermakespy-0.3.4 → huntermakespy-0.4.0}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "hunterMakesPy"
-version = "0.3.4"
+version = "0.4.0"
 description = "Easy Python functions making making functional Python functions easier."
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.12"
 license = { 'text' = "CC-BY-NC-4.0" }
 authors = [{ name = "Hunter Hogan", email = "HunterHogan@pm.me" }]
 keywords = [
@@ -37,7 +37,6 @@ classifiers = [
   "Operating System :: OS Independent",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",