hunterMakesPy 0.7.5__tar.gz → 0.8.1__tar.gz

{huntermakespy-0.7.5 → huntermakespy-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.7.5
+Version: 0.8.1
 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,12 +17,12 @@ 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.11
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Z0Z_tools>=2.2.1

{huntermakespy-0.7.5 → huntermakespy-0.8.1}/hunterMakesPy/__init__.py

@@ -69,11 +69,13 @@ References
 from __future__ import annotations
 
 from hunterMakesPy.semiotics import (
-	decreasing as decreasing, errorL33T as errorL33T, inclusive as inclusive, oneIndexed as oneIndexed, zeroIndexed as zeroIndexed)
+	ansiColor as ansiColor, ansiColorReset as ansiColorReset, decreasing as decreasing, errorL33T as errorL33T, inclusive as inclusive,
+	oneIndexed as oneIndexed, zeroIndexed as zeroIndexed)
 
 # 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.5 → huntermakespy-0.8.1}/hunterMakesPy/coping.py

@@ -12,14 +12,17 @@ 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
+	#ruff: ignore[docstring-missing-returns]
+	"""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
+	#ruff: ignore[docstring-missing-returns]
+	"""Return the root directory of the installed package."""
 	try:
 		moduleSpecification: ModuleSpec | None = find_spec(identifierPackage)
 		if moduleSpecification and moduleSpecification.origin:
@@ -54,8 +57,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:
@@ -117,7 +118,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 +130,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,11 +137,6 @@ 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

{huntermakespy-0.7.5 → huntermakespy-0.8.1}/hunterMakesPy/dataStructures.py

@@ -1,41 +1,43 @@
 """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
+	#ruff: ignore[docstring-missing-returns]
+	"""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 +72,8 @@ 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
+			#ruff: ignore[docstring-missing-returns]
+			"""`assumeAddSpaces` characters: `,` 1 space; `]*` 2 spaces."""
 			return assumeAddSpaces * (optionAsStr.count(',') + optionAsStr.count(']*') * 2) + len(optionAsStr)
 
 		if 1 < arraySlice.ndim:
@@ -92,7 +95,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 +125,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 +149,20 @@ 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
+		#ruff: ignore[docstring-missing-returns]
+		"""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 +178,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 +222,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 +246,98 @@ 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` [2]
+	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
+	[2] Python `sorted`.
+		https://docs.python.org/3/library/functions.html#sorted
+	"""
+	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.5 → huntermakespy-0.8.1}/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,58 @@ 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` [1], then opens the file in
+	append mode with UTF-8 encoding and `newline=''` [2]. Newline characters in `this` are written
+	without translation. This function writes and flushes the text with `writeStringToHere` [3].
+	Directory creation suppresses `OSError`, but errors from opening or writing the file propagate.
+
+	Examples
+	--------
+	No invocation of this function exists elsewhere in the codebase.
+
+	References
+	----------
+	[1] `makeDirectorySafely`
+
+	[2] Python `open` modes, encoding, and newline handling.
+		https://docs.python.org/3/library/functions.html#open
+	[3] `writeStringToHere`
+
+	"""
+	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,6 +136,7 @@ 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
@@ -118,7 +173,7 @@ def importPathFilename2Identifier(pathFilename: PathLike[Any] | PurePath, identi
 		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)

{huntermakespy-0.7.5 → huntermakespy-0.8.1}/hunterMakesPy/parseParameters.py

@@ -1,20 +1,13 @@
-# ruff: noqa: TRY301, DOC501, PLW0717 BLE001
-"""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` [1] by default and also
+accepts numeric strings. Binary integer inputs use `charset_normalizer` [2] for text decoding.
 
 Contents
 --------
@@ -26,11 +19,15 @@ Functions
 	oopsieKwargsie
 		Interpret a string as True, False, or None to avoid exceptions.
 
+Classes
+	ErrorMessageContext
+		Store value, type, and container information for integer-validation error messages.
+
 References
 ----------
-[1] multiprocessing - Context7
+[1] Python `multiprocessing`.
 	https://docs.python.org/3/library/multiprocessing.html
-[2] charset-normalizer - Context7
+[2] charset-normalizer.
 	https://github.com/Ousret/charset_normalizer
 
 """
@@ -45,8 +42,8 @@ import sys
 
 if TYPE_CHECKING:
 	from charset_normalizer.models import CharsetMatch
-	from collections.abc import Iterable
-	from hunterMakesPy.theTypes import Limitation
+	from collections.abc import Collection
+	from hunterMakesPy.theTypes import ConcurrencyLimit
 	from typing import Any
 
 @dataclass
@@ -71,49 +68,78 @@ 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` [1] 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` [2], 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` [3]. 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` [4] 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.
+		```python
+		from hunterMakesPy.parseParameters import defineConcurrencyLimit
 
-	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`.
-	```
+		workers = defineConcurrencyLimit(limit=0.75)
+		```
 
+	References
+	----------
+	[1] `oopsieKwargsie`
+
+	[2] Python `round`.
+		https://docs.python.org/3/library/functions.html#round
+	[3] Python `concurrent.futures.ProcessPoolExecutor`.
+		https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ProcessPoolExecutor
+	[4] Python `multiprocessing.cpu_count`.
+		https://docs.python.org/3/library/multiprocessing.html#multiprocessing.cpu_count
 	"""
 	if isinstance(limit, str):
 		limitFromString: bool | str | None = oopsieKwargsie(limit)
@@ -142,7 +168,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)
@@ -195,7 +221,7 @@ def _constructErrorMessage(context: ErrorMessageContext, parameterName: str, par
 
 	return "".join(messageParts)
 
-def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None, parameterType: type[Any] | None = None) -> list[int]:
+def intInnit(listInt_Allegedly: Collection[Any], parameterName: str | None = None, parameterType: type[Any] | None = None) -> list[int]:
 	"""Validate and convert input values to a `list` of integers.
 
 	Accepts various numeric types and attempts to convert them into integers while providing descriptive error messages. This
@@ -204,7 +230,7 @@ def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None,
 
 	Parameters
 	----------
-	listInt_Allegedly : Iterable[Any]
+	listInt_Allegedly : Collection[Any]
 		The input sequence that should contain integer-compatible values. Accepts integers, strings, floats, complex numbers, and
 		binary data. Rejects boolean values and non-integer numeric values.
 	parameterName : str | None = None
@@ -236,11 +262,12 @@ def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None,
 	parameterType = parameterType or list
 
 	if not listInt_Allegedly:
-		message: str = f"I did not receive a value for {parameterName}, but it is required."
+		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
@@ -250,19 +277,18 @@ def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None,
 		listValidated: list[int] = []
 
 		for allegedInt in listInt_Allegedly:
-
 			errorMessageContext: ErrorMessageContext = ErrorMessageContext(
-				parameterValue=allegedInt,
-				parameterValueType=type(allegedInt).__name__,
-				isElement=True
+				parameterValue=allegedInt
+				, parameterValueType=type(allegedInt).__name__
+				, 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
@@ -289,29 +315,23 @@ def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None,
 
 			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 ERRORmessage:
-		if isinstance(ERRORmessage.args[0], ErrorMessageContext):
-			context: ErrorMessageContext = ERRORmessage.args[0]
+	except (TypeError, ValueError) as ERROR:
+		if isinstance(ERROR.args[0], ErrorMessageContext):
+			context: ErrorMessageContext = ERROR.args[0]
 			if not context.containerType:
 				context.containerType = type(listInt_Allegedly).__name__
 			message = _constructErrorMessage(context, parameterName, parameterType)
-			raise type(ERRORmessage)(message) from None
-		# If it's not our Exception, don't molest it
-		raise
-
-	except RuntimeError as ERRORruntime:
-		lengthCurrent: int
-		lengthInitial, lengthCurrent = ERRORruntime.args[0]
-		ERRORmessage = (
-			f"The input sequence {parameterName} was modified during iteration. "
-			f"Initial length {lengthInitial}, current length {lengthCurrent}."
-		)
-		raise RuntimeError(
-			ERRORmessage
-		) from None
+			raise type(ERROR)(message) from None
+		#If it's not our Exception, don't molest it
+		raise ValueError from ERROR
+
+	except RuntimeError as ERROR:
+		lengthInitial, lengthCurrent = ERROR.args[0]
+		message = (f"`{parameterName}` was modified during iteration: {lengthInitial = }, current length {lengthCurrent = }.")
+		raise RuntimeError(message) from None
 
 	else:
 		return listValidated
@@ -338,6 +358,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.5 → huntermakespy-0.8.1}/hunterMakesPy/semiotics.py

@@ -326,7 +326,7 @@ References
 #======== 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.
@@ -503,3 +503,5 @@ class AnsiColors(NamedTuple):
 	YellowOnBlack: str = '\x1b[33;40m'
 	YellowOnBlue: str = '\x1b[33;44m'
 	YellowOnRed: str = '\x1b[33;41m'
+
+ansiColor = AnsiColors()

{huntermakespy-0.7.5 → huntermakespy-0.8.1}/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.8.1/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.5 → huntermakespy-0.8.1}/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.5 → huntermakespy-0.8.1}/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.5 → huntermakespy-0.8.1}/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.5 → huntermakespy-0.8.1}/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.5 → huntermakespy-0.8.1}/hunterMakesPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.7.5
+Version: 0.8.1
 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,12 +17,12 @@ 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.11
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: Z0Z_tools>=2.2.1

{huntermakespy-0.7.5 → huntermakespy-0.8.1}/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.5 → huntermakespy-0.8.1}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "hunterMakesPy"
-version = "0.7.5"
+version = "0.8.1"
 description = "Easy Python functions making making functional Python functions easier."
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "CC-BY-NC-4.0"
 authors = [{ name = "Hunter Hogan", email = "HunterHogan@pm.me" }]
 keywords = [
@@ -20,7 +20,7 @@ classifiers = [
   "Natural Language :: English",
   "Operating System :: OS Independent",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.14",
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: Utilities",