hunterMakesPy 0.7.6__tar.gz → 0.9.0__tar.gz

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.7.6
+Version: 0.9.0
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License-Expression: CC-BY-NC-4.0
@@ -17,15 +17,15 @@ Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: Z0Z_tools>=2.2.1
+Requires-Dist: Z0Z_tools>=4.0.0
 Requires-Dist: autoflake
 Requires-Dist: charset_normalizer
 Requires-Dist: isort
@@ -185,6 +185,11 @@ def test_my_integer_validator(test_name, test_func):
 ## My recovery
 
 [![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
-[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
 
 [![CC-BY-NC-4.0](https://raw.githubusercontent.com/hunterhogan/hunterMakesPy/refs/heads/main/.github/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)
+
+By law, authors retain their copyrights unless they grant exceptions. The [Attribution-NonCommercial 4.0 International Deed](https://github.com/hunterhogan/hunterMakesPy#License-1-ov-file) outlines how you may use this work.
+
+The restriction on commercial use (without a license) limits advantage-taking, unjust enrichment, and exploitation. You would be morally wrong if you were to enrich yourself by using this work while I am denied healthcare, housing, security of property, and the safety of my person.
+
+To obtain and retain the right to use this work, you incur the cost of attributing the work to me. Your nominal cost might accrue as a benefit that mitigates my suffering or saves my life.

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/README.md

@@ -143,6 +143,11 @@ def test_my_integer_validator(test_name, test_func):
 ## My recovery
 
 [![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
-[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
 
 [![CC-BY-NC-4.0](https://raw.githubusercontent.com/hunterhogan/hunterMakesPy/refs/heads/main/.github/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)
+
+By law, authors retain their copyrights unless they grant exceptions. The [Attribution-NonCommercial 4.0 International Deed](https://github.com/hunterhogan/hunterMakesPy#License-1-ov-file) outlines how you may use this work.
+
+The restriction on commercial use (without a license) limits advantage-taking, unjust enrichment, and exploitation. You would be morally wrong if you were to enrich yourself by using this work while I am denied healthcare, housing, security of property, and the safety of my person.
+
+To obtain and retain the right to use this work, you incur the cost of attributing the work to me. Your nominal cost might accrue as a benefit that mitigates my suffering or saves my life.

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/__init__.py

@@ -74,7 +74,8 @@ from hunterMakesPy.semiotics import (
 
 # isort: split
 from hunterMakesPy.theTypes import (
-	CallableFunction as CallableFunction, identifierDotAttribute as identifierDotAttribute, Ordinals as Ordinals, 小于 as 小于)
+	CallableFunction as CallableFunction, ConcurrencyLimit as ConcurrencyLimit, identifierDotAttribute as identifierDotAttribute,
+	Ordinals as Ordinals, 小于 as 小于, 文义 as 文义, 文件 as 文件)
 
 # isort: split
 from hunterMakesPy.coping import PackageSettings as PackageSettings, raiseIfNone as raiseIfNone

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/coping.py

@@ -12,14 +12,15 @@ if TYPE_CHECKING:
 	from importlib.machinery import ModuleSpec
 
 def getIdentifierPackagePACKAGING(identifierPackageFALLBACK: str) -> str:
-	"""Get package name from pyproject.toml or fallback to provided value."""  # noqa: DOC201
+	"""Get package name from pyproject.toml or fallback to provided value."""
 	try:
 		return tomli_loads(Path('pyproject.toml').read_text(encoding='utf-8'))['project']['name']
-	except Exception:  # noqa: BLE001
+	#ruff: ignore[blind-except]
+	except Exception:
 		return identifierPackageFALLBACK
 
 def getPathPackageINSTALLING(identifierPackage: str) -> Path:
-	"""Return the root directory of the installed package."""  # noqa: DOC201
+	"""Return the root directory of the installed package."""
 	try:
 		moduleSpecification: ModuleSpec | None = find_spec(identifierPackage)
 		if moduleSpecification and moduleSpecification.origin:
@@ -54,8 +55,6 @@ class PackageSettings:
 
 	```python
 	settings = PackageSettings(identifierPackageFALLBACK='cobraPy')
-	# Automatically discovers package name from pyproject.toml
-	# Resolves installation path from package identifier
 	```
 
 	Explicit configuration for specific deployment:
@@ -67,7 +66,6 @@ class PackageSettings:
 		fileExtension='.pyx'
 	)
 	```
-
 	"""
 
 	identifierPackageFALLBACK: dataclasses.InitVar[str] = ''
@@ -117,7 +115,6 @@ def raiseIfNone(expression: TypeSansNone | None, errorMessage: str | None = None
 	Basic usage with attribute access:
 	```python
 	annotation = raiseIfNone(ast_arg.annotation)
-	# Raises ValueError if ast_arg.annotation is None
 	```
 
 	Function return value validation:
@@ -130,7 +127,6 @@ def raiseIfNone(expression: TypeSansNone | None, errorMessage: str | None = None
 
 	listFiles = ['document.txt', 'image.png', 'data.csv']
 	filename = raiseIfNone(findFirstMatch(listFiles, '.txt'))
-	# Returns 'document.txt' when match exists
 	```
 
 	Dictionary value retrieval with custom message:
@@ -138,17 +134,11 @@ def raiseIfNone(expression: TypeSansNone | None, errorMessage: str | None = None
 	configurationMapping = {'host': 'localhost', 'port': 8080}
 	host = raiseIfNone(configurationMapping.get('host'),
 					"Configuration must include 'host' setting")
-	# Returns 'localhost' when key exists
-
-	# This would raise ValueError with custom message:
-	# database = raiseIfNone(configurationMapping.get('database'),
-	#                      "Configuration must include 'database' setting")
 	```
 
 	Thanks
 	------
 	sobolevn, https://github.com/sobolevn, for the seed of this function. https://github.com/python/typing/discussions/1997#discussioncomment-13108399
-
 	"""
 	if expression is None:
 		message: str = errorMessage or 'A function unexpectedly returned `None`. Hint: look at the traceback immediately before `raiseIfNone`.'

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/dataStructures.py

@@ -1,41 +1,42 @@
 """Manipulate data structures with encoding, extraction, and merging utilities.
 
-You can use this module to transform arrays (in the general sense) into compact run-length encoded
-strings, extract strings from arbitrarily nested data structures, or merge dictionaries of lists.
+You can use this module to encode integer arrays as compact Python expressions, extract strings
+from nested data, normalize whitespace in representations of Python data, and merge mappings of
+iterable values into dictionaries of lists.
 
 Contents
 --------
 Functions
 	autoDecodingRLE
-		Transform a NumPy array into a compact, self-decoding run-length encoded string
-		representation.
+		Encode an integer array as a compact Python expression.
+	removeExtraWhitespace
+		Remove whitespace after commas and inside parentheses or square brackets.
 	stringItUp
 		Convert every element in input data structures to strings.
 	updateExtendPolishDictionaryLists
-		Merge multiple dictionaries with list values into a single dictionary.
+		Merge iterable values into lists with optional deduplication and sorting.
 """
 from __future__ import annotations
 
 from charset_normalizer import CharsetMatch
-from collections.abc import Hashable
-from humpy_cytoolz.dicttoolz import valmap
+from humpy_cytoolz.dicttoolz import valmap as mapValues
 from humpy_cytoolz.functoolz import compose
 from types import FunctionType
-from typing import cast, TYPE_CHECKING, TypeVar
+from typing import cast, overload, TYPE_CHECKING
 import charset_normalizer
 import more_itertools
 import re as regex
 import sys
 
 if TYPE_CHECKING:
-	from collections.abc import Iterator, Mapping
-	from hunterMakesPy import 小于
+	from collections.abc import Callable, Iterable, Iterator, Mapping
+	from hunterMakesPy import 小于, 文义, 文件
 	from numpy import integer
 	from numpy.typing import NDArray
-	from typing import Any
+	from typing import Any, Literal
 
 def removeExtraWhitespace(string: str) -> str:
-	"""Remove extra whitespace from string representation of Python data structures."""  # noqa: DOC201
+	"""Remove extra whitespace from string representation of Python data structures."""
 	commas: str = regex.sub(r',\s+', ',', string)
 	bracketsOpening: str = regex.sub(r'([\[\(])\s+', r'\1', commas)
 	return regex.sub(r'\s+([\]\)])', r'\1', bracketsOpening)
@@ -70,7 +71,7 @@ def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool
 	"""
 	def sliceNDArrayToNestedLists(arraySlice: NDArray[integer[Any]]) -> Any:
 		def getLengthOption(optionAsStr: str) -> int:
-			"""`assumeAddSpaces` characters: `,` 1 space; `]*` 2 spaces."""  # noqa: DOC201
+			"""`assumeAddSpaces` characters: `,` 1 space; `]*` 2 spaces."""
 			return assumeAddSpaces * (optionAsStr.count(',') + optionAsStr.count(']*') * 2) + len(optionAsStr)
 
 		if 1 < arraySlice.ndim:
@@ -92,7 +93,6 @@ def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool
 					option2 = ImaSerious
 					option2AsStr: str | None = None
 
-					# alpha, potential function
 					option1AsStr: str = option1AsStr or removeExtraWhitespace(str(option1))
 					lengthOption1: int = getLengthOption(option1AsStr)
 
@@ -123,7 +123,6 @@ def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool
 					option2 = malkovichAsList
 					option2AsStr = None
 
-					# beta, potential function
 					option1AsStr = option1AsStr or removeExtraWhitespace(str(option1))
 					lengthOption1 = getLengthOption(option1AsStr)
 
@@ -148,19 +147,19 @@ def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool
 
 	patternRegex: regex.Pattern[str] = regex.compile(
 		r"(?<!rang)(?:"
-		# Pattern 1: Comma ahead, bracket behind
+		#Pattern 1: Comma ahead, bracket behind
 		r"(?P<joinAhead>,)\((?P<malkovich>\d+),(?P<multiply>\d+)\)(?P<bracketBehind>])|"
-		# Pattern 2: Bracket or start ahead, comma behind
+		#Pattern 2: Bracket or start ahead, comma behind
 		r"(?P<bracketOrStartAhead>\[|^.)\((?P<malkovichMalkovich>\d+),(?P<multiplyIDK>\d+)\)(?P<joinBehind>,)|"
-		# Pattern 3: Bracket ahead, bracket behind
+		#Pattern 3: Bracket ahead, bracket behind
 		r"(?P<bracketAhead>\[)\((?P<malkovichMalkovichMalkovich>\d+),(?P<multiply_whatever>\d+)\)(?P<bracketBehindBracketBehind>])|"
-		# Pattern 4: Comma ahead, comma behind
+		#Pattern 4: Comma ahead, comma behind
 		r"(?P<joinAheadJoinAhead>,)\((?P<malkovichMalkovichMalkovichMalkovich>\d+),(?P<multiplyOrSomething>\d+)\)(?P<joinBehindJoinBehind>,)"
 		r")"
 	)
 
 	def replacementByContext(match: regex.Match[str]) -> str:
-		"""Generate replacement string based on context patterns."""  # noqa: DOC201
+		"""Generate replacement string based on context patterns."""
 		elephino: dict[str, str | None] = match.groupdict()
 		joinAhead: str | None = elephino.get('joinAhead') or elephino.get('joinAheadJoinAhead')
 		malkovich: str | None = elephino.get('malkovich') or elephino.get('malkovichMalkovich') or elephino.get('malkovichMalkovichMalkovich') or elephino.get('malkovichMalkovichMalkovichMalkovich')
@@ -176,8 +175,8 @@ def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool
 	arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
 	arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
 
-	# .replace `range(0,stop)` syntax with `range(stop)` syntax.
-	# Add unpack operator `*` for automatic decoding when evaluated.
+	#.replace `range(0,stop)` syntax with `range(stop)` syntax.
+	#Add unpack operator `*` for automatic decoding when evaluated.
 	return arrayAsStr.replace('range(0,', 'range(').replace('range', '*range')
 
 def stringItUp(*scrapPile: Any) -> list[str]:
@@ -220,16 +219,18 @@ def stringItUp(*scrapPile: Any) -> list[str]:
 		elif isinstance(KitKat, (list, tuple, set, frozenset, range)):
 			for kit in KitKat:  # pyright: ignore[reportUnknownVariableType]
 				drill(kit)
-		elif hasattr(KitKat, '__iter__'):  # Unpack other iterables
+		elif hasattr(KitKat, '__iter__'):
 			for kat in KitKat:
 				drill(kat)
 		else:
 			try:
-				sharingIsCaring: str = KitKat.__str__()  # noqa: PLC2801
+				#ruff: ignore[unnecessary-dunder-call]
+				sharingIsCaring: str = KitKat.__str__()
 				listStrungUp.append(sharingIsCaring)
 			except AttributeError:
 				pass
-			except TypeError:  # "The error traceback provided indicates that there is an issue when calling the __str__ method on an object that does not have this method properly defined, leading to a TypeError."
+			except TypeError:
+				#"The error traceback provided indicates that there is an issue when calling the __str__ method on an object that does not have this method properly defined, leading to a TypeError."
 				pass
 			except:
 				message: str = (f"\nWoah! I received '{repr(KitKat)}'.\nTheir report card says, 'Plays well with others: Needs improvement.'\n")
@@ -242,55 +243,96 @@ def stringItUp(*scrapPile: Any) -> list[str]:
 		listStrungUp.append(repr(scrap))
 	return listStrungUp
 
-文件 = TypeVar('文件', bound=Hashable)
+@overload
+def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[文件, Iterable[文义]], destroyDuplicates: bool = False, reorderLists: Literal[False] = False, killErroneousDataTypes: bool = False) -> dict[文件, list[文义]]: ...
 
-# TODO if `reorderLists: bool = False`, the elements do not need to be ordinals, and they should be covariant.
-def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[文件, list[小于] | set[小于] | tuple[小于, ...]], destroyDuplicates: bool = False, reorderLists: bool = False, killErroneousDataTypes: bool = False) -> dict[文件, list[小于]]:
-	"""Merge multiple dictionaries with `list` values into a single dictionary with the `list` values merged.
+@overload
+def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[文件, Iterable[小于]], destroyDuplicates: bool = False, reorderLists: Literal[True], killErroneousDataTypes: bool = False) -> dict[文件, list[小于]]: ...
 
-	Plus options to destroy duplicates, sort `list` values, and handle erroneous data types.
+@overload
+def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[文件, Iterable[小于]], destroyDuplicates: bool = False, reorderLists: bool, killErroneousDataTypes: bool = False) -> dict[文件, list[小于]]: ...
+
+def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[文件, Iterable[文义]], destroyDuplicates: bool = False, reorderLists: bool = False, killErroneousDataTypes: bool = False) -> dict[文件, list[文义]]:
+	"""Merge mappings of iterable values into a dictionary of lists.
+
+	You can use this function to combine values under matching keys across `dictionaryLists`.
+	This function returns a new dictionary with new lists and can remove duplicate elements,
+	sort elements, or skip entries that raise `TypeError` during merging.
+
+	Iteration and Ordering
+	----------------------
+	This function consumes each value's iterable in mapping argument order. Within each value,
+	the list follows the iterable's order, which may be unpredictable for sets. Strings contribute
+	individual characters, and mapping values contribute their keys.
+
+	Deduplication uses `dict.fromkeys` [1] to preserve first occurrences. Sorting uses `sorted`
+	and runs after deduplication. Every retained value becomes a list regardless of the input type.
 
 	Parameters
 	----------
-	*dictionaryLists : MutableMapping[文件, list[Any] | set[Any] | tuple[Any, ...]]
-		Variable number of dictionaries to be merged. If only one dictionary is passed, it will be
-		"polished".
+	*dictionaryLists : Mapping[文件, Iterable[文义]]
+		The mappings to merge, with hashable keys and iterable values. A single mapping receives
+		the same conversion and optional processing. No mappings produce an empty dictionary.
 	destroyDuplicates : bool = False
-		If `True`, removes duplicate elements from the `list`. Defaults to `False`.
+		If `True`, remove duplicate elements from each merged list, preserving the first occurrence.
+		Elements must be hashable when this option is enabled.
 	reorderLists : bool = False
-		If `True`, sorts each `list` value. Defaults to `False`. The elements must be comparable;
-		otherwise, a `TypeError` will be raised.
+		If `True`, sort each merged list in ascending order after optional deduplication.
+		Elements within each list must be mutually comparable.
 	killErroneousDataTypes : bool = False
-		If `True`, suppresses any `TypeError` `Exception` and omits the dictionary key or value that
-		caused the `Exception`. Defaults to `False`.
+		If `True`, skip an entry when converting the entry's value to a list or merging the entry
+		raises `TypeError`. Successfully merged values for the same key remain in the result.
+		This option does not suppress `TypeError` from deduplication or sorting.
 
 	Returns
 	-------
-	ePluribusUnum : dict[文件, list[Any]]
-		A single dictionary with merged and optionally "polished" `list` values.
-
-	Notes
-	-----
-	The returned value, `ePluribusUnum`, is a dictionary (`dict`). Furthermore, every dictionary value
-	is a `list`. If `dictionaryLists` has values that are not data type `list`, the data type will not
-	be preserved. That could have unexpected consequences. Conversion from the original data type to a
-	`list`, for example, may not preserve the order even if you want the order to be preserved.
-	"""  # noqa: DOC501
-	ePluribusUnum: dict[文件, list[小于]] = {}
+	ePluribusUnum : dict[文件, list[文义]]
+		The merged dictionary, with a list for every retained key. This function does not modify
+		the input mappings or their containers, but the lists retain references to the original elements.
+
+	Raises
+	------
+	TypeError
+		If a value cannot be iterated or an entry cannot be merged and `killErroneousDataTypes`
+		is `False`. Also raised for unhashable elements during deduplication or incomparable
+		elements during sorting, regardless of `killErroneousDataTypes`.
+
+	Examples
+	--------
+	The README merges server lists while preserving the first occurrence of each server name.
+
+		```python
+		from hunterMakesPy.dataStructures import updateExtendPolishDictionaryLists
+
+		merged = updateExtendPolishDictionaryLists(
+			{"servers": ["chicago"]},
+			{"servers": ["tokyo", "chicago"]},
+			destroyDuplicates=True,
+		)
+		# Returns {"servers": ["chicago", "tokyo"]}.
+		```
+
+	References
+	----------
+	[1] Python dictionaries and `dict.fromkeys`.
+		https://docs.python.org/3/library/stdtypes.html#dict.fromkeys
+	"""
+	ePluribusUnum: dict[文件, list[文义]] = {}
 
 	for dictionaryListTarget in dictionaryLists:
 		for keyName, keyValue in dictionaryListTarget.items():
 			try:
-				ImaList: list[小于] = list(keyValue)
+				ImaList: list[文义] = list(keyValue)
 				ePluribusUnum.setdefault(keyName, []).extend(ImaList)
-			except TypeError as error:  # noqa: PERF203
+			except TypeError as error:
 				if killErroneousDataTypes:
 					continue
 				raise TypeError from error
 
 	if destroyDuplicates:
-		ePluribusUnum = valmap(compose(list, dict.fromkeys), ePluribusUnum)
+		ePluribusUnum = mapValues(compose(list, dict.fromkeys), ePluribusUnum)
 	if reorderLists:
-		ePluribusUnum = valmap(sorted, ePluribusUnum)
+		#=SIN= `sorted` is broken.
+		ePluribusUnum = mapValues(cast('Callable[[list[文义]], list[文义]]', sorted), ePluribusUnum)
 
 	return ePluribusUnum

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/filesystemToolkit.py

@@ -1,41 +1,43 @@
-"""Access dynamic import utilities and text-writing utilities.
+"""Import Python identifiers and write or append text to files.
 
 (AI generated docstring)
 
 You can use this module to import `identifier` values from logical module paths or Python files,
-create parent directories for output paths, and write text or formatted Python source to files and
-text streams. The writing functions can normalize Python imports with `autoflake` [1] and `isort` [2]
-before the destination receives the final text.
+create parent directories for output paths, append text to files, and write text or formatted Python
+source to files and text streams. The writing functions can normalize Python imports with
+`autoflake` [1] and `isort` [2] before the destination receives the final text.
 
 Contents
 --------
 Functions
-    importLogicalPath2Identifier
-        Import `identifier` from the module named by `logicalPathModule`.
-    importPathFilename2Identifier
-        Import `identifier` from the Python file at `pathFilename`.
-    makeDirectorySafely
-        Create parent directories for `pathFilename` when `pathFilename` is a filesystem path.
-    makeDirsSafely
-        Temporary alias for `makeDirectorySafely`.
-    writePython
-        Format `pythonSource` and write `pythonSource` to `pathFilename`.
-    writeStringToHere
-        Write `this` to `pathFilename`.
+	appendStringToHere
+		Append `this` to `pathFilename` without changing existing text.
+	importLogicalPath2Identifier
+		Import `identifier` from the module named by `logicalPathModule`.
+	importPathFilename2Identifier
+		Import `identifier` from the Python file at `pathFilename`.
+	makeDirectorySafely
+		Create parent directories for `pathFilename` when `pathFilename` is a filesystem path.
+	makeDirsSafely
+		Temporary alias for `makeDirectorySafely`.
+	writePython
+		Format `pythonSource` and write `pythonSource` to `pathFilename`.
+	writeStringToHere
+		Write `this` to `pathFilename`.
 
 Variables
 ---------
-    settings_autoflakeDEFAULT
-        Default settings dictionary for Python source cleanup.
-    settings_isortDEFAULT
-        Default settings dictionary for Python import sorting.
+	settings_autoflakeDEFAULT
+		Default settings dictionary for Python source cleanup.
+	settings_isortDEFAULT
+		Default settings dictionary for Python import sorting.
 
 References
 ----------
 [1] autoflake
-    https://github.com/PyCQA/autoflake
+	https://github.com/PyCQA/autoflake
 [2] isort
-    https://pycqa.github.io/isort/
+	https://pycqa.github.io/isort/
 """
 from __future__ import annotations
 
@@ -55,6 +57,49 @@ if TYPE_CHECKING:
 	from types import ModuleType
 	from typing import Any
 
+def appendStringToHere(this: str, pathFilename: PathLike[Any] | PurePath) -> Path:
+	"""Append `this` to the UTF-8 file at `pathFilename`.
+
+	(AI generated docstring)
+
+	You can use this function to add text to the end of a file while preserving existing text. This
+	function creates missing parent directories when possible and creates the file when needed.
+	This function returns the destination path after writing and closing the file.
+
+	Parameters
+	----------
+	this : str
+		The text to append. This function does not add a separator or trailing newline.
+	pathFilename : PathLike[Any] | PurePath
+		The destination file path. This function accepts a filesystem path rather than an open stream.
+
+	Returns
+	-------
+	destinationAppended : Path
+		The destination path as a `Path`, without resolving the path to an absolute path.
+
+	See Also
+	--------
+	`writeStringToHere`
+		Replace a file's contents or write to an open text stream.
+
+	File Writing
+	------------
+	This function prepares parent directories with `makeDirectorySafely`, then opens the file in
+	append mode with UTF-8 encoding and `newline=''`. Newline characters in `this` are written
+	without translation. This function writes and flushes the text with `writeStringToHere`.
+	Directory creation suppresses `OSError`, but errors from opening or writing the file propagate.
+
+	Examples
+	--------
+	No invocation of this function exists elsewhere in the codebase.
+	"""
+	pathFilename = Path(pathFilename)
+	makeDirectorySafely(pathFilename)
+	with pathFilename.open(encoding='utf-8', mode='a', newline='') as streamAppend:
+		writeStringToHere(this, streamAppend)
+	return pathFilename
+
 def importLogicalPath2Identifier(logicalPathModule: identifierDotAttribute, identifier: str, packageIdentifierIfRelative: str | None = None) -> Any:
 	"""Import `identifier` from the module named by `logicalPathModule`.
 
@@ -82,12 +127,13 @@ def importLogicalPath2Identifier(logicalPathModule: identifierDotAttribute, iden
 	return getattr(moduleImported, identifier)
 
 def importPathFilename2Identifier(pathFilename: PathLike[Any] | PurePath, identifier: str, moduleIdentifier: str | None = None) -> Any:
+	#ruff: ignore[docstring-extraneous-exception]
 	"""Import `identifier` from the Python file at `pathFilename`.
 
 	You can use this function to load a Python source file as a module and retrieve a named attribute
 	from that module. This function builds a module specification with
-	`importlib.util.spec_from_file_location` [1], executes the loaded module with
-	`importlib.util.module_from_spec` [2], and returns the attribute selected by `identifier`.
+	`importlib.util.spec_from_file_location`, executes the loaded module with
+	`importlib.util.module_from_spec`, and returns the attribute selected by `identifier`.
 
 	Parameters
 	----------
@@ -111,14 +157,7 @@ def importPathFilename2Identifier(pathFilename: PathLike[Any] | PurePath, identi
 		Raised when the loader cannot read `pathFilename`.
 	AttributeError
 		Raised when the loaded module does not define `identifier`.
-
-	References
-	----------
-	[1] `importlib.util.spec_from_file_location`
-		https://docs.python.org/3/library/importlib.html#importlib.util.spec_from_file_location
-	[2] `importlib.util.module_from_spec`
-		https://docs.python.org/3/library/importlib.html#importlib.util.module_from_spec
-	"""  # noqa: DOC502
+	"""
 	pathFilename = Path(pathFilename)
 
 	importlibSpecification: ModuleSpec | None = importlib.util.spec_from_file_location(moduleIdentifier or pathFilename.stem, pathFilename)
@@ -134,21 +173,14 @@ def makeDirectorySafely(pathFilename: Any) -> None:
 	"""Create parent directories for `pathFilename` when `pathFilename` is a filesystem path.
 
 	You can use this function to prepare an output location before a later write operation. This
-	function ignores `OSError` from `Path.mkdir` [1] and does nothing when `pathFilename` is an
-	`IOBase` [2] stream.
+	function ignores `OSError` from `Path.mkdir` and does nothing when `pathFilename` is an
+	`IOBase` stream.
 
 	Parameters
 	----------
 	pathFilename : Any
 		The target path or open stream. When `pathFilename` is not an `IOBase` instance, the
 		function creates the parent directory of `pathFilename`.
-
-	References
-	----------
-	[1] `pathlib.Path.mkdir`
-		https://docs.python.org/3/library/pathlib.html#pathlib.Path.mkdir
-	[2] `IOBase`
-		https://docs.python.org/3/library/io.html#io.IOBase
 	"""
 	if not isinstance(pathFilename, IOBase):
 		with contextlib.suppress(OSError):
@@ -241,7 +273,7 @@ def writeStringToHere(this: str, pathFilename: PathLike[Any] | PurePath | TextIO
 
 	You can use this function to send text to a filesystem path or an open text stream. This function
 	creates the parent directory when `pathFilename` is path-like, writes UTF-8 text with
-	`Path.write_text` [1], or writes and flushes a `TextIOBase` [2] stream.
+	`Path.write_text`, or writes and flushes a `TextIOBase` stream.
 
 	Parameters
 	----------
@@ -271,13 +303,6 @@ def writeStringToHere(this: str, pathFilename: PathLike[Any] | PurePath | TextIO
 		pathFilename.relative_to(pathTransformee)
 	)
 	```
-
-	References
-	----------
-	[1] `pathlib.Path.write_text`
-		https://docs.python.org/3/library/pathlib.html#pathlib.Path.write_text
-	[2] `TextIOBase`
-		https://docs.python.org/3/library/io.html#io.TextIOBase
 	"""
 	if isinstance(pathFilename, TextIOBase):
 		pathFilename.write(str(this))

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/parseParameters.py

@@ -1,20 +1,13 @@
-# ruff: file-ignore[raise-within-try, docstring-missing-exception, too-many-statements-in-try-clause, blind-except]
-"""Validate parameters and parse input with defensive error handling.
+# ruff: file-ignore[raise-within-try]
+"""Validate integer inputs, calculate worker counts, and interpret string parameters.
 
 (AI generated docstring)
 
-You can use this module to validate and convert input sequences to integers, determine
-concurrency limits based on flexible parameter specifications, and interpret string values
-as boolean or None types. The module provides strict validation functions that follow
-fail-early principles with descriptive error messages for debugging.
-
-The integer validation function accepts various numeric types including strings, floats,
-complex numbers, and binary data, converting them to integers while detecting ambiguous
-or incompatible values. The concurrency limit function interprets boolean, integer, and
-float values to compute processor counts with support for absolute limits, fractional
-allocation, and reserved-processor specifications. The string interpretation function
-attempts to parse string values as True, False, or None to handle parameter type mismatches
-gracefully.
+You can use this module to convert integer-compatible inputs into lists of integers, calculate
+worker counts from absolute or fractional limits, and interpret strings as `True`, `False`, or
+`None`. Integer validation reports incompatible values with context about the caller's parameter.
+Worker-count calculation uses the system CPU count from `multiprocessing` by default and also
+accepts numeric strings. Binary integer inputs use `charset_normalizer` for text decoding.
 
 Contents
 --------
@@ -26,13 +19,9 @@ Functions
 	oopsieKwargsie
 		Interpret a string as True, False, or None to avoid exceptions.
 
-References
-----------
-[1] multiprocessing - Context7
-	https://docs.python.org/3/library/multiprocessing.html
-[2] charset-normalizer - Context7
-	https://github.com/Ousret/charset_normalizer
-
+Classes
+	ErrorMessageContext
+		Store value, type, and container information for integer-validation error messages.
 """
 from __future__ import annotations
 
@@ -46,7 +35,7 @@ import sys
 if TYPE_CHECKING:
 	from charset_normalizer.models import CharsetMatch
 	from collections.abc import Collection
-	from hunterMakesPy.theTypes import Limitation
+	from hunterMakesPy.theTypes import ConcurrencyLimit
 	from typing import Any
 
 @dataclass
@@ -71,49 +60,67 @@ class ErrorMessageContext:
 	containerType: str | None = None
 	isElement: bool = False
 
-def defineConcurrencyLimit(*, limit: Limitation, cpuTotal: int = multiprocessing.cpu_count()) -> int:
-	"""Determine the concurrency limit based on the provided parameter.
+def defineConcurrencyLimit(*, limit: ConcurrencyLimit, cpuTotal: int = multiprocessing.cpu_count()) -> int:
+	"""Calculate a worker count from an absolute, fractional, or reserved-CPU limit.
+
+	You can use this function to select a worker count from `limit` and `cpuTotal`. This function
+	accepts explicit counts, fractions of `cpuTotal`, counts to reserve, and boolean choices.
+	This function also accepts numeric strings and strings representing `True`, `False`, or `None`.
+	The result is at least one worker and is at most 61 workers on Windows.
+
+	String Parsing
+	--------------
+	This function first uses `oopsieKwargsie` to interpret strings representing `True`, `False`,
+	or `None`, ignoring capitalization and surrounding whitespace. Other strings are converted
+	with `float`. An invalid numeric string raises `ValueError` with the conversion error as the cause.
+
+	Processor Counts
+	----------------
+	This function rounds floating-point counts whose absolute value is at least one before applying
+	the count rules. Rounding uses Python `round`, including rounding ties to the nearest even
+	integer. This function applies the following rules before enforcing the platform bounds.
+
+	- `None`, `False`, or zero select `cpuTotal`.
+	- `True` selects one worker.
+	- A positive count of at least one selects that count.
+	- A positive fraction below one selects `round(limit * cpuTotal)` workers.
+	- A negative fraction above negative one reserves `abs(round(limit * cpuTotal))` CPUs.
+	- A negative count of at most negative one reserves `abs(int(limit))` CPUs.
+
+	This function caps the result at 61 on Windows, matching the restriction for
+	`concurrent.futures.ProcessPoolExecutor`. This function then enforces the minimum of one.
 
 	Parameters
 	----------
-	limit : bool | float | int | None
-		Whether and how to limit CPU usage. See notes and examples for details how to describe the options to your users.
+	limit : ConcurrencyLimit
+		The worker-count specification. `None`, `False`, or zero select `cpuTotal`; `True` selects
+		one worker. Positive counts select workers to use, and negative counts select CPUs to reserve.
+		Fractions between negative one and one select proportions to reserve or use, respectively.
+		Strings are also accepted at runtime, although the type annotation excludes strings.
 	cpuTotal : int = multiprocessing.cpu_count()
-		The total number of CPUs available in the system. Default is `multiprocessing.cpu_count()`.
+		The CPU count used for fractional limits and reserved-CPU calculations. The default is the
+		value of `multiprocessing.cpu_count` evaluated when this module is imported.
 
 	Returns
 	-------
 	concurrencyLimit : int
-		The calculated concurrency limit, ensuring it is at least 1.
+		The calculated worker count, with a minimum of one and a Windows maximum of 61.
+		An explicit positive count can exceed `cpuTotal`.
 
-	Example parameters
-	------------------
-	```python
-	CPUlimit: bool | float | int | None
-	CPUlimit: Limitation = None
-	```
+	Raises
+	------
+	ValueError
+		If a string does not represent a number, `True`, `False`, or `None`.
 
-	Example docstring
-	-----------------
-	```python
+	Examples
+	--------
+	The README selects three quarters of the default CPU count.
 
-	Arguments
-	---------
-	CPUlimit: bool | float | int | None
-		Whether and how to limit the the number of available processors used by the function. See notes for details.
-
-	Notes
-	-----
-	Limits on CPU usage, `CPUlimit`:
-		- `False`, `None`, or `0`: No limits on processor usage; uses all available processors. All other values will potentially limit processor usage.
-		- `True`: Yes, limit the processor usage; limits to 1 processor.
-		- `int >= 1`: The maximum number of available processors to use.
-		- `0 < float < 1`: The maximum number of processors to use expressed as a fraction of available processors.
-		- `-1 < float < 0`: The number of processors to *not* use expressed as a fraction of available processors.
-		- `int <= -1`: The number of available processors to *not* use.
-		- If the value of `CPUlimit` is a `float` greater than 1 or less than -1, the function truncates the value to an `int` with the same sign as the `float`.
-	```
+		```python
+		from hunterMakesPy.parseParameters import defineConcurrencyLimit
 
+		workers = defineConcurrencyLimit(limit=0.75)
+		```
 	"""
 	if isinstance(limit, str):
 		limitFromString: bool | str | None = oopsieKwargsie(limit)
@@ -142,7 +149,7 @@ def defineConcurrencyLimit(*, limit: Limitation, cpuTotal: int = multiprocessing
 	elif limit <= -1:
 		concurrencyLimit = cpuTotal - abs(int(limit))
 
-	# https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ProcessPoolExecutor
+	#https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ProcessPoolExecutor
 	if sys.platform == "win32":
 		concurrencyLimit = min(concurrencyLimit, 61)
 	return max(int(concurrencyLimit), 1)
@@ -170,7 +177,6 @@ def _constructErrorMessage(context: ErrorMessageContext, parameterName: str, par
 	-------
 	errorMessage : str
 		The constructed error message string.
-
 	"""
 	messageParts: list[str] = ["I received "]
 
@@ -239,8 +245,9 @@ def intInnit(listInt_Allegedly: Collection[Any], parameterName: str | None = Non
 		message: str = f"I did not receive a value for `{parameterName}`, but I must have it."
 		raise ValueError(message)
 
-	# Be nice, and assume the input container is valid and every element is valid.
-	# Nevertheless, this is a "fail-early" step, so reject ambiguity and try to induce errors now that could be catastrophic later.
+	#Be nice, and assume the input container is valid and every element is valid.
+	#Nevertheless, this is a "fail-early" step, so reject ambiguity and try to induce errors now that could be catastrophic later.
+	#ruff: ignore[too-many-statements-in-try-clause]
 	try:
 		iter(listInt_Allegedly)
 		lengthInitial: int | None = None
@@ -256,12 +263,12 @@ def intInnit(listInt_Allegedly: Collection[Any], parameterName: str | None = Non
 				, isElement=True
 			)
 
-			# Always rejected as ambiguous
+			#Always rejected as ambiguous
 			if isinstance(allegedInt, bool):
 				raise TypeError(errorMessageContext)
 
-			# In this section, we know the Python type is not `int`, but maybe the value is clearly an integer.
-			# Through a series of conversions, allow data to cascade down into either an `int` or a meaningful error message.
+			#In this section, we know the Python type is not `int`, but maybe the value is clearly an integer.
+			#Through a series of conversions, allow data to cascade down into either an `int` or a meaningful error message.
 
 			if isinstance(allegedInt, (bytes, bytearray, memoryview)):
 				errorMessageContext.parameterValue = None  # Don't expose potentially garbled binary data in error messages
@@ -288,7 +295,7 @@ def intInnit(listInt_Allegedly: Collection[Any], parameterName: str | None = Non
 
 			listValidated.append(allegedInt)
 
-			if lengthInitial is not None and isinstance(listInt_Allegedly, Sized) and len(listInt_Allegedly) != lengthInitial:
+			if lengthInitial is not None and isinstance(listInt_Allegedly, Sized) and len(listInt_Allegedly) != lengthInitial:  # pyright: ignore[reportUnnecessaryComparison]
 				raise RuntimeError((lengthInitial, len(listInt_Allegedly)))
 
 	except (TypeError, ValueError) as ERROR:
@@ -298,8 +305,8 @@ def intInnit(listInt_Allegedly: Collection[Any], parameterName: str | None = Non
 				context.containerType = type(listInt_Allegedly).__name__
 			message = _constructErrorMessage(context, parameterName, parameterType)
 			raise type(ERROR)(message) from None
-		# If it's not our Exception, don't molest it
-		raise
+		#If it's not our Exception, don't molest it
+		raise ValueError from ERROR
 
 	except RuntimeError as ERROR:
 		lengthInitial, lengthCurrent = ERROR.args[0]
@@ -331,6 +338,7 @@ def oopsieKwargsie(huh: Any) -> bool | str | None:
 	if not isinstance(huh, str):
 		try:
 			huh = str(huh)
+		#ruff: ignore[blind-except]
 		except BaseException:
 			return huh
 	formatted: str = huh.strip().title()

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/semiotics.py

@@ -117,7 +117,7 @@ expects negative error indicators. The leetspeak encoding makes `errorL33T` imme
 in debugger output, log files, or printed state, reducing the risk of overlooking error conditions
 that might be missed with generic values like `-1`.
 
-In rare cases when code execution does not raise `Exception` [2] but produces incorrect output,
+In rare cases when code execution does not raise `Exception` but produces incorrect output,
 seeing `31212012` or `-31212012` in the output provides a stronger diagnostic signal than `-1` or
 other conventional error values. The distinctive value helps identify which variables hold error
 states without requiring careful inspection of every numeric field.
@@ -150,9 +150,6 @@ References
 ----------
 [1] Leet - Wikipedia
 	https://en.wikipedia.org/wiki/Leet
-[2] Built-in Exceptions - `Exception` (Python documentation)
-	https://docs.python.org/3/library/exceptions.html#Exception
-
 """
 
 inclusive: Final[int] = 1
@@ -323,10 +320,11 @@ References
 
 """
 
+# TODO Can I use Python's color system? It is shockingly similar in structure and even identifiers.
 #======== Some colors for printing text to the terminal. ========
 # Many values and options at https://gist.github.com/JBlond/2fea43a3049b38287e5e9cefc87b2124
 # Many, many, many options at https://stackoverflow.com/a/33206814/4403878
-# NOTE Always define color and background color at the same time.
+# Always define color and background color at the same time.
 
 ansiColorReset: Final[str] = '\x1b[0m'
 """Reset terminal text color and background to default settings.

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/tests/conftest.py

@@ -41,7 +41,7 @@ def pathTmpTesting(tmp_path: pathlib.Path) -> pathlib.Path:
 # Fixture for predictable Python source code samples
 @pytest.fixture
 def dictionaryPythonSourceSamples() -> dict[str, str]:
-	"""Provide predictable Python source code samples for testing."""  # noqa: DOC201
+	"""Provide predictable Python source code samples for testing."""
 	return {
 		'functionFibonacci': "def fibonacciNumber():\n    return 13\n",
 		'functionPrime': "def primeNumber():\n    return 17\n",
@@ -53,19 +53,19 @@ def dictionaryPythonSourceSamples() -> dict[str, str]:
 # Fixture for IO stream objects
 @pytest.fixture
 def streamMemoryString() -> io.StringIO:
-	"""Provide a StringIO object for testing stream operations."""  # noqa: DOC201
+	"""Provide a StringIO object for testing stream operations."""
 	return io.StringIO()
 
 # Fixture for predictable directory names using cardinal directions
 @pytest.fixture
 def listDirectoryNamesCardinal() -> list[str]:
-	"""Provide predictable directory names using cardinal directions."""  # noqa: DOC201
+	"""Provide predictable directory names using cardinal directions."""
 	return ['north', 'south', 'east', 'west']
 
 # Fixture for predictable file content using Fibonacci numbers
 @pytest.fixture
 def listFileContentsFibonacci() -> list[str]:
-	"""Provide predictable file contents using Fibonacci sequence."""  # noqa: DOC201
+	"""Provide predictable file contents using Fibonacci sequence."""
 	return ['fibonacci8', 'fibonacci13', 'fibonacci21', 'fibonacci34']
 
 def uniformTestFailureMessage(expected: Any, actual: Any, functionName: str, *arguments: Any, **keywordArguments: Any) -> str:
@@ -115,7 +115,7 @@ def standardizedEqualTo(expected: Any, functionTarget: Callable[..., Any], *argu
 		Keyword arguments to pass to `functionTarget`.
 
 	"""
-	if type(expected) == type[Exception]:  # noqa: E721
+	if type(expected) == type[Exception]:  # ruff: ignore[type-comparison]
 		messageExpected: str = expected.__name__
 	else:
 		messageExpected = expected
@@ -130,7 +130,7 @@ def standardizedEqualTo(expected: Any, functionTarget: Callable[..., Any], *argu
 	assert actual == expected, uniformTestFailureMessage(messageExpected, messageActual, functionName, *arguments, **keywordArguments)
 
 # Why I wish I could figure out how to implement standardized* test functions.
-# ruff: noqa: ERA001
+# ruff: file-ignore[commented-out-code]
 	# standardizedEqualTo(expected, updateExtendPolishDictionaryLists, *value_dictionaryLists, **keywordArguments)
 # NOTE one line of code with `standardizedEqualTo` (above) replaced the following ten lines of code. Use `standardizedEqualTo`.
 	# if isinstance(expected, type) and issubclass(expected, Exception):

huntermakespy-0.9.0/hunterMakesPy/tests/conftestAnnex.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from itertools import starmap
+from typing import TYPE_CHECKING
+import pytest
+
+if TYPE_CHECKING:
+	from typing import Any
+
+#================== Assert scalar and built-in containers ========================================================================
+
+def assertEqualTo[个](actual: 个, expected: 个, function: str, *arguments: Any, **keywordArguments: Any) -> None:
+	"""Assert that two objects are equal, and if not, raise an AssertionError with a detailed message."""
+	assert actual == expected, messageTestFailure(actual, expected, function, *arguments, **keywordArguments)
+
+def assert_approx[个](actual: 个, expected: 个, pytest_rel: float, pytest_abs: float, function: str, *arguments: Any, **keywordArguments: Any) -> None:
+	assert actual == pytest.approx(expected, pytest_rel, pytest_abs, nan_ok=True), messageTestFailure(actual, expected, function, *arguments, **keywordArguments)
+
+def messageTestFailure(actual: Any, expected: Any, function: str, *arguments: Any, **keywordArguments: Any) -> str:
+	"""Format assertion message for any test comparison."""
+	parameters: list[str] = [*map(repr, arguments), *starmap('{}={!r}'.format, keywordArguments.items())]
+	return f'{function}({", ".join(parameters)}) = {actual!r}, but {expected = }.'

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/tests/test_dataStructures.py

@@ -161,7 +161,7 @@ def test_autoDecodingRLE(
 		"range": range,
 		"list": list,
 	}
-	value_arrayTarget: NDArray[numpy.integer[Any]] = eval(arrayExpression, evaluationContext)  # noqa: S307
+	value_arrayTarget: NDArray[numpy.integer[Any]] = eval(arrayExpression, evaluationContext)  # ruff: ignore[suspicious-eval-usage]
 
 	resultRLE: str = autoDecodingRLE(value_arrayTarget, assumeAddSpaces=assumeAddSpaces)
 
@@ -179,7 +179,7 @@ def test_autoDecodingRLE(
 
 	assert resultRLE == expected, (f"autoDecodingRLE made {resultRLE!r}, expected {expected!r} for {description=} and {assumeAddSpaces=}.")
 
-	decodedData = eval(resultRLE)  # noqa: S307
+	decodedData = eval(resultRLE)  # ruff: ignore[suspicious-eval-usage]
 	reconstructedArray: NDArray[numpy.integer[Any]] = numpy.array(decodedData)
 	numpy.testing.assert_array_equal(
 		reconstructedArray

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/tests/test_theTypes.py

@@ -10,8 +10,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from hunterMakesPy import CallableFunction as CallableFunction
 from hunterMakesPy.tests.conftest import uniformTestFailureMessage
-from typing import TYPE_CHECKING
-from typing_extensions import Self
+from typing import Self, TYPE_CHECKING
 import pytest
 
 if TYPE_CHECKING:

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/theTypes.py

@@ -1,9 +1,9 @@
 """I type, you type, we all `type` for `theTypes`."""
 from __future__ import annotations
 
+from collections.abc import Hashable
 from hunterMakesPy.theTypesCallableFunction import CallableFunction as CallableFunction
-from typing import Protocol, TypeAlias
-from typing_extensions import Self, TypeVar
+from typing import Protocol, Self, TypeAlias, TypeVar
 
 identifierDotAttribute: TypeAlias = str
 """`str` (***str***ing) representing a dotted attribute identifier.
@@ -11,7 +11,7 @@ identifierDotAttribute: TypeAlias = str
 `TypeAlias` for a `str` `object` using dot notation to access an attribute, such as 'scipy.signal.windows'.
 """
 
-Limitation: TypeAlias = bool | float | int | None
+ConcurrencyLimit: TypeAlias = bool | float | int | None
 
 class Ordinals(Protocol):
 	"""Any Python `object` `type` that may be ordered before or after a comparable `object` `type` by comparison operators."""
@@ -25,3 +25,5 @@ class Ordinals(Protocol):
 		...
 
 小于 = TypeVar('小于', bound=Ordinals)
+文件 = TypeVar('文件', bound=Hashable)
+文义 = TypeVar('文义')

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy/theTypesCallableFunction.py

@@ -7,17 +7,8 @@ import sys
 
 if TYPE_CHECKING:
 	from types import CodeType, MethodType
-	from typing import TypeAlias
-	from typing_extensions import Self, TypeVarTuple
-
-# TODO explore the following
-"""
-I've added new test cases using a lambda function and a standard user-defined imported function
-(stringItUp itself). Built-in functions like len don't trigger the FunctionType check because their
-type is technically a builtin_function_or_method in CPython, whereas functions defined via def or
-lambda correspond exactly to types.FunctionType. Your coverage should now reflect this branch as
-expected reflect activation of that branch.
-"""
+	from typing import Self, TypeAlias
+	from typing_extensions import TypeVarTuple
 
 #======== Copied from typeshed:stdlib\_typeshed\__init__.pyi ========
 AnnotationForm: TypeAlias = Any
@@ -25,7 +16,6 @@ AnnotationForm: TypeAlias = Any
 if (3, 14) <= sys.version_info:
 	from annotationlib import Format
 
-# NOTE These return annotations, which can be arbitrary objects
 	AnnotateFunc: TypeAlias = Callable[[Format], dict[str, AnnotationForm]]
 	EvaluateFunc: TypeAlias = Callable[[Format], AnnotationForm]
 #======== End Copied from typeshed:stdlib\_typeshed\__init__.pyi ========

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.7.6
+Version: 0.9.0
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License-Expression: CC-BY-NC-4.0
@@ -17,15 +17,15 @@ Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: Z0Z_tools>=2.2.1
+Requires-Dist: Z0Z_tools>=4.0.0
 Requires-Dist: autoflake
 Requires-Dist: charset_normalizer
 Requires-Dist: isort
@@ -185,6 +185,11 @@ def test_my_integer_validator(test_name, test_func):
 ## My recovery
 
 [![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
-[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
 
 [![CC-BY-NC-4.0](https://raw.githubusercontent.com/hunterhogan/hunterMakesPy/refs/heads/main/.github/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)
+
+By law, authors retain their copyrights unless they grant exceptions. The [Attribution-NonCommercial 4.0 International Deed](https://github.com/hunterhogan/hunterMakesPy#License-1-ov-file) outlines how you may use this work.
+
+The restriction on commercial use (without a license) limits advantage-taking, unjust enrichment, and exploitation. You would be morally wrong if you were to enrich yourself by using this work while I am denied healthcare, housing, security of property, and the safety of my person.
+
+To obtain and retain the right to use this work, you incur the cost of attributing the work to me. Your nominal cost might accrue as a benefit that mitigates my suffering or saves my life.

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ hunterMakesPy.egg-info/requires.txt
 hunterMakesPy.egg-info/top_level.txt
 hunterMakesPy/tests/__init__.py
 hunterMakesPy/tests/conftest.py
+hunterMakesPy/tests/conftestAnnex.py
 hunterMakesPy/tests/test_coping.py
 hunterMakesPy/tests/test_dataStructures.py
 hunterMakesPy/tests/test_filesystemToolkit.py

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/hunterMakesPy.egg-info/requires.txt

@@ -1,4 +1,4 @@
-Z0Z_tools>=2.2.1
+Z0Z_tools>=4.0.0
 autoflake
 charset_normalizer
 isort

{huntermakespy-0.7.6 → huntermakespy-0.9.0}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "hunterMakesPy"
-version = "0.7.6"
+version = "0.9.0"
 description = "Easy Python functions making making functional Python functions easier."
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.12"
 license = "CC-BY-NC-4.0"
 authors = [{ name = "Hunter Hogan", email = "HunterHogan@pm.me" }]
 keywords = [
@@ -20,14 +20,14 @@ classifiers = [
   "Natural Language :: English",
   "Operating System :: OS Independent",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.15",
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: Utilities",
   "Typing :: Typed",
 ]
 dependencies = [
-  "Z0Z_tools>=2.2.1",
+  "Z0Z_tools>=4.0.0",
   "autoflake",
   "charset_normalizer",
   "isort",