hunterMakesPy 0.1.2__tar.gz → 0.2.0__tar.gz

{huntermakespy-0.1.2 → huntermakespy-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.1.2
+Version: 0.2.0
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
@@ -32,7 +33,7 @@ License-File: LICENSE
 Requires-Dist: charset_normalizer
 Requires-Dist: more_itertools
 Requires-Dist: numpy
-Requires-Dist: python_minifier
+Requires-Dist: python_minifier; python_version < "3.14"
 Provides-Extra: development
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"

{huntermakespy-0.1.2 → huntermakespy-0.2.0}/hunterMakesPy/__init__.py

@@ -7,6 +7,7 @@ This package provides:
 - Utilities for string extraction from nested data structures and merging dictionaries of lists.
 
 """
+# pyright: reportUnusedImport=false
 from hunterMakesPy.theTypes import identifierDotAttribute as identifierDotAttribute
 
 from hunterMakesPy.coping import PackageSettings as PackageSettings, raiseIfNone as raiseIfNone
@@ -18,7 +19,11 @@ from hunterMakesPy.filesystemToolkit import (importLogicalPath2Identifier as imp
 	importPathFilename2Identifier as importPathFilename2Identifier, makeDirsSafely as makeDirsSafely,
 	writeStringToHere as writeStringToHere)
 
-from hunterMakesPy.dataStructures import (autoDecodingRLE as autoDecodingRLE, stringItUp as stringItUp,
-	updateExtendPolishDictionaryLists as updateExtendPolishDictionaryLists)
+from hunterMakesPy.dataStructures import stringItUp as stringItUp, updateExtendPolishDictionaryLists as updateExtendPolishDictionaryLists
+
+import sys
+
+if sys.version_info < (3, 14):
+    from hunterMakesPy.dataStructures import autoDecodingRLE as autoDecodingRLE
 
 from hunterMakesPy._theSSOT import settingsPackage

huntermakespy-0.2.0/hunterMakesPy/dataStructures.py

@@ -0,0 +1,268 @@
+"""Provides utilities for string extraction from nested data structures and merges multiple dictionaries containing lists into one dictionary."""
+
+from collections.abc import Iterator, Mapping
+from numpy import integer
+from numpy.typing import NDArray
+from typing import Any
+import more_itertools
+import re as regex
+import sys
+
+if sys.version_info < (3, 14):
+	import python_minifier
+
+	def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool = False) -> str:  # noqa: C901, PLR0915
+		"""Transform a NumPy array into a compact, self-decoding run-length encoded string representation.
+
+		This function converts a NumPy array into a string that, when evaluated as Python code,
+		recreates the original array structure. The function employs two compression strategies:
+		1. Python's `range` syntax for consecutive integer sequences
+		2. Multiplication syntax for repeated elements
+
+		The resulting string representation is designed to be both human-readable and space-efficient,
+		especially for large cartesian mappings with repetitive patterns. When this string is used
+		as a data source, Python will automatically decode it into Python `list`, which if used as an
+		argument to `numpy.array()`, will recreate the original array structure.
+
+		Parameters
+		----------
+		arrayTarget : NDArray[integer[Any]]
+			(array2target) The NumPy array to be encoded.
+		assumeAddSpaces : bool = False
+			(assume2add2spaces) Affects internal length comparison during compression decisions.
+			This parameter doesn't directly change output format but influences whether
+			`range` or multiplication syntax is preferred in certain cases. The parameter
+			exists because the Abstract Syntax Tree (AST) inserts spaces in its string
+			representation.
+
+		Returns
+		-------
+		rleString : str
+			(rle2string) A string representation of the array using run-length encoding that,
+			when evaluated as Python code, reproduces the original array structure.
+
+		Notes
+		-----
+		The "autoDecoding" feature means that the string representation evaluates directly
+		to the desired data structure without explicit decompression steps.
+
+		"""
+		def sliceNDArrayToNestedLists(arraySlice: NDArray[integer[Any]]) -> Any:
+			def getLengthOption(optionAsStr: str) -> int:
+				"""`assumeAddSpaces` characters: `,` 1; `]*` 2."""
+				return assumeAddSpaces * (optionAsStr.count(',') + optionAsStr.count(']*') * 2) + len(optionAsStr)
+
+			if arraySlice.ndim > 1:
+				axisOfOperation = 0
+				return [sliceNDArrayToNestedLists(arraySlice[index]) for index in range(arraySlice.shape[axisOfOperation])]
+			if arraySlice.ndim == 1:
+				arraySliceAsList: list[int | range] = []
+				cache_consecutiveGroup_addMe: dict[Iterator[Any], list[int] | list[range]] = {}
+				for consecutiveGroup in more_itertools.consecutive_groups(arraySlice.tolist()):
+					if consecutiveGroup in cache_consecutiveGroup_addMe:
+						addMe = cache_consecutiveGroup_addMe[consecutiveGroup]
+					else:
+						ImaSerious: list[int] = list(consecutiveGroup)
+						ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
+						ImaRangeAsStr = python_minifier.minify(str(ImaRange)).replace('range(0,', 'range(').replace('range', '*range')
+
+						option1 = ImaRange
+						option1AsStr = ImaRangeAsStr
+						option2 = ImaSerious
+						option2AsStr = None
+
+						# alpha, potential function
+						option1AsStr = option1AsStr or python_minifier.minify(str(option1))
+						lengthOption1 = getLengthOption(option1AsStr)
+
+						option2AsStr = option2AsStr or python_minifier.minify(str(option2))
+						lengthOption2 = getLengthOption(option2AsStr)
+
+						if lengthOption1 < lengthOption2:
+							addMe = option1
+						else:
+							addMe = option2
+
+						cache_consecutiveGroup_addMe[consecutiveGroup] = addMe
+
+					arraySliceAsList += addMe
+
+				listRangeAndTuple: list[int | range | tuple[int | range, int]] = []
+				cache_malkovichGrouped_addMe: dict[tuple[int | range, int], list[tuple[int | range, int]] | list[int | range]] = {}
+				for malkovichGrouped in more_itertools.run_length.encode(arraySliceAsList):
+					if malkovichGrouped in cache_malkovichGrouped_addMe:
+						addMe = cache_malkovichGrouped_addMe[malkovichGrouped]
+					else:
+						lengthMalkovich = malkovichGrouped[-1]
+						malkovichAsList = list(more_itertools.run_length.decode([malkovichGrouped]))
+						malkovichMalkovich = f"[{malkovichGrouped[0]}]*{lengthMalkovich}"
+
+						option1 = [malkovichGrouped]
+						option1AsStr = malkovichMalkovich
+						option2 = malkovichAsList
+						option2AsStr = None
+
+						# beta, potential function
+						option1AsStr = option1AsStr or python_minifier.minify(str(option1))
+						lengthOption1 = getLengthOption(option1AsStr)
+
+						option2AsStr = option2AsStr or python_minifier.minify(str(option2))
+						lengthOption2 = getLengthOption(option2AsStr)
+
+						if lengthOption1 < lengthOption2:
+							addMe = option1
+						else:
+							addMe = option2
+
+						cache_malkovichGrouped_addMe[malkovichGrouped] = addMe
+
+					listRangeAndTuple += addMe
+
+				return listRangeAndTuple
+			return arraySlice
+
+		arrayAsNestedLists = sliceNDArrayToNestedLists(arrayTarget)
+
+		arrayAsStr = python_minifier.minify(str(arrayAsNestedLists))
+
+		patternRegex = regex.compile(
+			"(?<!rang)(?:"
+			# Pattern 1: Comma ahead, bracket behind  # noqa: ERA001
+			"(?P<joinAhead>,)\\((?P<malkovich>\\d+),(?P<multiply>\\d+)\\)(?P<bracketBehind>])|"
+			# Pattern 2: Bracket or start ahead, comma behind  # noqa: ERA001
+			"(?P<bracketOrStartAhead>\\[|^.)\\((?P<malkovichMalkovich>\\d+),(?P<multiplyIDK>\\d+)\\)(?P<joinBehind>,)|"
+			# Pattern 3: Bracket ahead, bracket behind  # noqa: ERA001
+			"(?P<bracketAhead>\\[)\\((?P<malkovichMalkovichMalkovich>\\d+),(?P<multiply_whatever>\\d+)\\)(?P<bracketBehindBracketBehind>])|"
+			# Pattern 4: Comma ahead, comma behind  # noqa: ERA001
+			"(?P<joinAheadJoinAhead>,)\\((?P<malkovichMalkovichMalkovichMalkovich>\\d+),(?P<multiplyOrSomething>\\d+)\\)(?P<joinBehindJoinBehind>,)"
+			")"
+		)
+
+		def replacementByContext(match: regex.Match[str]) -> str:
+			"""Generate replacement string based on context patterns."""
+			elephino = match.groupdict()
+			joinAhead = elephino.get('joinAhead') or elephino.get('joinAheadJoinAhead')
+			malkovich = elephino.get('malkovich') or elephino.get('malkovichMalkovich') or elephino.get('malkovichMalkovichMalkovich') or elephino.get('malkovichMalkovichMalkovichMalkovich')
+			multiply = elephino.get('multiply') or elephino.get('multiplyIDK') or elephino.get('multiply_whatever') or elephino.get('multiplyOrSomething')
+			joinBehind = elephino.get('joinBehind') or elephino.get('joinBehindJoinBehind')
+
+			replaceAhead = "]+[" if joinAhead == "," else "["
+
+			replaceBehind = "+[" if joinBehind == "," else ""
+
+			return f"{replaceAhead}{malkovich}]*{multiply}{replaceBehind}"
+
+		arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
+		arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
+
+		# Replace `range(0,stop)` syntax with `range(stop)` syntax.  # noqa: ERA001
+		# Add unpack operator `*` for automatic decoding when evaluated.
+		return arrayAsStr.replace('range(0,', 'range(').replace('range', '*range')
+
+def stringItUp(*scrapPile: Any) -> list[str]:  # noqa: C901
+	"""Convert, if possible, every element in the input data structure to a string.
+
+	Order is not preserved or readily predictable.
+
+	Parameters
+	----------
+	*scrapPile : Any
+		(scrap2pile) One or more data structures to unpack and convert to strings.
+
+	Returns
+	-------
+	listStrungUp : list[str]
+		(list2strung2up) A `list` of string versions of all convertible elements.
+
+	"""
+	scrap = None
+	listStrungUp: list[str] = []
+
+	def drill(KitKat: Any) -> None:  # noqa: C901, PLR0912
+		match KitKat:
+			case str():
+				listStrungUp.append(KitKat)
+			case bool() | bytearray() | bytes() | complex() | float() | int() | memoryview() | None:
+				listStrungUp.append(str(KitKat)) # pyright: ignore [reportUnknownArgumentType]
+			case dict():
+				for broken, piece in KitKat.items(): # pyright: ignore [reportUnknownVariableType]
+					drill(broken)
+					drill(piece)
+			case list() | tuple() | set() | frozenset() | range():
+				for kit in KitKat: # pyright: ignore [reportUnknownVariableType]
+					drill(kit)
+			case _:
+				if hasattr(KitKat, '__iter__'):  # Unpack other iterables
+					for kat in KitKat:
+						drill(kat)
+				else:
+					try:
+						sharingIsCaring = 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."
+						pass
+					except:
+						print(f"\nWoah! I received '{repr(KitKat)}'.\nTheir report card says, 'Plays well with others: Needs improvement.'\n")  # noqa: RUF010, T201
+						raise
+	try:
+		for scrap in scrapPile:
+			drill(scrap)
+	except RecursionError:
+		listStrungUp.append(repr(scrap))
+	return listStrungUp
+
+def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[str, list[Any] | set[Any] | tuple[Any, ...]], destroyDuplicates: bool = False, reorderLists: bool = False, killErroneousDataTypes: bool = False) -> dict[str, list[Any]]:
+	"""Merge multiple dictionaries containing `list` into a single dictionary.
+
+	With options to handle duplicates, `list` ordering, and erroneous data types.
+
+	Parameters
+	----------
+	*dictionaryLists : Mapping[str, list[Any] | set[Any] | tuple[Any, ...]]
+		(dictionary2lists) Variable number of dictionaries to be merged. If only one dictionary is passed, it will be processed based on the provided options.
+	destroyDuplicates : bool = False
+		(destroy2duplicates) If `True`, removes duplicate elements from the `list`. Defaults to `False`.
+	reorderLists : bool = False
+		(reorder2lists) If `True`, sorts the `list`. Defaults to `False`.
+	killErroneousDataTypes : bool = False
+		(kill2erroneous2data2types) If `True`, skips dictionary keys or dictionary values that cause a `TypeError` during merging. Defaults to `False`.
+
+	Returns
+	-------
+	ePluribusUnum : dict[str, list[Any]]
+		(e2pluribus2unum) A single dictionary with merged `list` based on the provided options. If only one dictionary is passed,
+		it will be cleaned up based on the options.
+
+	Notes
+	-----
+	The returned value, `ePluribusUnum`, is a so-called primitive dictionary (`dict`). Furthermore, every dictionary key is a
+	so-called primitive string (cf. `str()`) and every dictionary value is a so-called primitive `list` (`list`). If
+	`dictionaryLists` has other data types, the data types 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.
+
+	"""
+	ePluribusUnum: dict[str, list[Any]] = {}
+
+	for dictionaryListTarget in dictionaryLists:
+		for keyName, keyValue in dictionaryListTarget.items():
+			try:
+				ImaStr = str(keyName)
+				ImaList = list(keyValue)
+				ePluribusUnum.setdefault(ImaStr, []).extend(ImaList)
+			except TypeError:
+				if killErroneousDataTypes:
+					continue
+				else:
+					raise
+
+	if destroyDuplicates:
+		for ImaStr, ImaList in ePluribusUnum.items():
+			ePluribusUnum[ImaStr] = list(dict.fromkeys(ImaList))
+	if reorderLists:
+		for ImaStr, ImaList in ePluribusUnum.items():
+			ePluribusUnum[ImaStr] = sorted(ImaList)
+
+	return ePluribusUnum

{huntermakespy-0.1.2 → huntermakespy-0.2.0}/hunterMakesPy/parseParameters.py

@@ -9,18 +9,16 @@ import multiprocessing
 class ErrorMessageContext:
 	"""Context information for constructing error messages.
 
-	(AI generated docstring)
-
 	Parameters
 	----------
 	parameterValue : Any = None
-		(parameter2value) The value that caused the error.
+		The value that caused the error.
 	parameterValueType : str | None = None
-		(parameter2value2type) The type name of the parameter value.
+		The name of the type of the parameter value.
 	containerType : str | None = None
-		(container2type) The type name of the container holding the parameter.
+		The name of the type of the container holding the parameter.
 	isElement : bool = False
-		(is2element) Whether the parameter is an element within a container.
+		Whether the parameter is an element within a container.
 
 	"""
 
@@ -32,7 +30,8 @@ class ErrorMessageContext:
 def _constructErrorMessage(context: ErrorMessageContext, parameterName: str, parameterType: type[Any] | None) -> str:
 	"""Construct error message from available context using template.
 
-	I received ["value" | a value | `None`] [of type `type` | `None`] [as an element in | `None`] [a `containerType` type | `None`] but `parameterName` must have integers [in type(s) `parameterType` | `None`].
+	I received ["value" | a value | `None`] [of type `type` | `None`] [as an element in | `None`] [a `containerType` type |
+	`None`] but `parameterName` must have integers [in type(s) `parameterType` | `None`].
 
 	Hypothetically, this is a prototype that can be generalized to other functions. In this package and a few of my other
 	packages, I have developed standardized error messages, but those are quite different from this. I will certainly continue to
@@ -41,16 +40,16 @@ def _constructErrorMessage(context: ErrorMessageContext, parameterName: str, par
 	Parameters
 	----------
 	context : ErrorMessageContext
-		(context) The error context containing parameter value, type, and container information.
+		The error context containing parameter value, type, and container information.
 	parameterName : str
-		(parameter2name) The name of the parameter that caused the error.
+		The name of the parameter that caused the error.
 	parameterType : type[Any] | None
-		(parameter2type) The expected type of the parameter, used in error messages.
+		The expected type of the parameter, used in error messages.
 
 	Returns
 	-------
 	errorMessage : str
-		(error2message) The constructed error message string.
+		The constructed error message string.
 
 	"""
 	messageParts = ["I received "]
@@ -79,7 +78,8 @@ def _constructErrorMessage(context: ErrorMessageContext, parameterName: str, par
 def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int = multiprocessing.cpu_count()) -> int:  # noqa: C901, PYI041
 	"""Determine the concurrency limit based on the provided parameter.
 
-	This package has Pytest tests you can import and run on this function. `from hunterMakesPy.pytest_parseParameters import makeTestSuiteConcurrencyLimit`
+	Tests for this function can be run with:
+	`from hunterMakesPy.tests.test_parseParameters import PytestFor_defineConcurrencyLimit`
 
 	Parameters
 	----------
@@ -92,12 +92,12 @@ def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int =
 	Returns
 	-------
 	concurrencyLimit : int
-		(concurrency2limit) The calculated concurrency limit, ensuring it is at least 1.
+		The calculated concurrency limit, ensuring it is at least 1.
 
 	Notes
 	-----
-	If you want to be extra nice to your users, consider using `hunterMakesPy.oopsieKwargsie()` to handle
-	malformed inputs. For example:
+	If you want to be extra nice to your users, consider using `hunterMakesPy.oopsieKwargsie()` to handle malformed inputs. For
+	example:
 
 	```
 	if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
@@ -163,23 +163,25 @@ def defineConcurrencyLimit(*, limit: bool | float | int | None, cpuTotal: int =
 def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None, parameterType: type[Any] | None = None) -> list[int]:  # noqa: C901, PLR0912, PLR0915
 	"""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.
+	Accepts various numeric types and attempts to convert them into integers while providing descriptive error messages. This
+	package includes Pytest tests that can be imported and run: `from hunterMakesPy.tests.test_parseParameters import
+	PytestFor_intInnit`.
 
 	Parameters
 	----------
 	listInt_Allegedly : Iterable[Any]
-		(list2int2allegedly) 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.
+		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
-		(parameter2name) Name of the parameter from your function for which this function is validating the input validated. If there is an error message, it provides context to your user. Defaults to 'the parameter'.
+		Name of the parameter from your function for which this function is validating the input validated. If there is an error
+		message, it provides context to your user. Defaults to 'the parameter'.
 	parameterType : type[Any] | None = None
-		(parameter2type) Expected type(s) of the parameter, used in error messages.
+		Expected type(s) of the parameter, used in error messages.
 
 	Returns
 	-------
 	listValidated : list[int]
-		(list2validated) A `list` containing validated integers.
+		A `list` containing validated integers.
 
 	Raises
 	------
@@ -192,9 +194,6 @@ def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None,
 
 	Notes
 	-----
-	This package includes Pytest tests that can be imported and run:
-	`from hunterMakesPy.pytest_parseParameters import makeTestSuiteIntInnit`
-
 	The function performs strict validation and follows fail-early principles to catch potential issues before they become catastrophic.
 
 	"""
@@ -284,19 +283,20 @@ def intInnit(listInt_Allegedly: Iterable[Any], parameterName: str | None = None,
 def oopsieKwargsie(huh: Any) -> bool | None | str:
 	"""Interpret a `str` as `True`, `False`, or `None` to avoid an `Exception`.
 
-	If a calling function passes a `str` to a parameter that shouldn't receive a `str`, `oopsieKwargsie()` might help you avoid an `Exception`. It tries to interpret the string as `True`, `False`, or `None`. This package has Pytest tests you can import and run on this function.
-	`from hunterMakesPy.pytest_parseParameters import makeTestSuiteOopsieKwargsie`
+	If a calling function passes a `str` to a parameter that shouldn't receive a `str`, `oopsieKwargsie()` might help you avoid an
+	`Exception`. It tries to interpret the string as `True`, `False`, or `None`.
+
+	Tests for this function can be run with: `from hunterMakesPy.tests.test_parseParameters import PytestFor_oopsieKwargsie`.
 
 	Parameters
 	----------
 	huh : Any
 		(huh) The input string to be parsed.
 
-
 	Returns
 	-------
 	interpretedValue : bool | None | str
-		(interpreted2value) The reserved keyword `True`, `False`, or `None` or the original string, `huh`.
+		The reserved keyword `True`, `False`, or `None` or the original string, `huh`.
 
 	"""
 	if not isinstance(huh, str):

huntermakespy-0.2.0/hunterMakesPy/pytestForYourUse.py

@@ -0,0 +1,10 @@
+"""Pytest tests you can use in your package to test some hunterMakesPy functions.
+
+Each function in this module returns a list of test functions that can be used with `pytest.parametrize`.
+
+Note: These test functions are now in `hunterMakesPy.tests` with all other tests.
+"""
+
+from hunterMakesPy.tests.test_parseParameters import (
+	PytestFor_defineConcurrencyLimit as PytestFor_defineConcurrencyLimit, PytestFor_intInnit as PytestFor_intInnit,
+	PytestFor_oopsieKwargsie as PytestFor_oopsieKwargsie)

huntermakespy-0.2.0/hunterMakesPy/tests/__init__.py

@@ -0,0 +1,5 @@
+"""Test modules for hunterMakesPy package.
+
+This module contains comprehensive test suites for all major functions and features in the hunterMakesPy package. Tests can be run
+independently or imported into your project.
+"""

{huntermakespy-0.1.2 → huntermakespy-0.2.0/hunterMakesPy}/tests/conftest.py

@@ -5,8 +5,7 @@ import pathlib
 import pytest
 
 # SSOT for test data paths and filenames
-# SSOT for test data paths and filenames
-pathDataSamples = pathlib.Path("tests/dataSamples")
+pathDataSamples = pathlib.Path("hunterMakesPy/tests/dataSamples")
 
 # Fixture to provide a temporary directory for filesystem tests
 @pytest.fixture

{huntermakespy-0.1.2 → huntermakespy-0.2.0/hunterMakesPy}/tests/test_coping.py

@@ -1,7 +1,7 @@
 from hunterMakesPy import PackageSettings, raiseIfNone
 from hunterMakesPy.coping import getIdentifierPackagePACKAGING, getPathPackageINSTALLING
+from hunterMakesPy.tests.conftest import uniformTestFailureMessage
 from pathlib import Path
-from tests.conftest import uniformTestFailureMessage
 import pytest
 
 @pytest.mark.parametrize(

{huntermakespy-0.1.2 → huntermakespy-0.2.0/hunterMakesPy}/tests/test_dataStructures.py

@@ -2,13 +2,17 @@
 from collections.abc import Callable, Iterable, Iterator
 from decimal import Decimal
 from fractions import Fraction
-from hunterMakesPy import autoDecodingRLE, stringItUp, updateExtendPolishDictionaryLists
+from hunterMakesPy import stringItUp, updateExtendPolishDictionaryLists
+from hunterMakesPy.tests.conftest import standardizedEqualTo
 from numpy.typing import NDArray
-from tests.conftest import standardizedEqualTo
 from typing import Any, Literal
 import datetime
 import numpy
 import pytest
+import sys
+
+if sys.version_info < (3, 14):
+	from hunterMakesPy import autoDecodingRLE
 
 class CustomIterable:
 	def __init__(self, items: Iterable[Any]) -> None: self.items = items
@@ -81,7 +85,7 @@ def testStringItUpErrorCases(description: Literal['Memory view'], value_scrapPil
 def testUpdateExtendPolishDictionaryLists(description: str, value_dictionaryLists: dict[str, Any], keywordArguments: dict[str, Any], expected: dict[str, Any] | type[TypeError]) -> None:
 	standardizedEqualTo(expected, updateExtendPolishDictionaryLists, *value_dictionaryLists, **keywordArguments)
 # ruff: noqa: ERA001
-# NOTE one line of code with `standardizedEqualTo` replaced the following ten lines of code.
+# NOTE one line of code with `standardizedEqualTo` replaced the following ten lines of code. Use `standardizedEqualTo`.
 	# if isinstance(expected, type) and issubclass(expected, Exception):
 	#	 with pytest.raises(expected):
 	#		 updateExtendPolishDictionaryLists(*value_dictionaryLists, **keywordArguments)
@@ -94,26 +98,28 @@ def testUpdateExtendPolishDictionaryLists(description: str, value_dictionaryList
 	#		 assert result == expected
 
 # ruff: noqa: RUF005
-@pytest.mark.parametrize("description,value_arrayTarget,expected", [
-	("One range", numpy.array(list(range(50,60))), "[*range(50,60)]"),
-	("Value, range", numpy.array([123]+list(range(71,81))), "[123,*range(71,81)]"),
-	("range, value", numpy.array(list(range(91,97))+[101]), "[*range(91,97),101]"),
-	("Value, range, value", numpy.array([151]+list(range(163,171))+[181]), "[151,*range(163,171),181]"),
-	("Repeat values", numpy.array([191, 191, 191]), "[191]*3"),
-	("Value with repeat", numpy.array([211, 223, 223, 223]), "[211]+[223]*3"),
-	("Range with repeat", numpy.array(list(range(251,257))+[271, 271, 271]), "[*range(251,257)]+[271]*3"),
-	("Value, range, repeat", numpy.array([281]+list(range(291,297))+[307, 307]), "[281,*range(291,297)]+[307]*2"),
-	("repeat, value", numpy.array([313, 313, 313, 331, 331, 349]), "[313]*3+[331]*2+[349]"),
-	("repeat, range", numpy.array([373, 373, 373]+list(range(383,389))), "[373]*3+[*range(383,389)]"),
-	("repeat, range, value", numpy.array(7*[401]+list(range(409,415))+[421]), "[401]*7+[*range(409,415),421]"),
-	("Repeated primes", numpy.array([431, 431, 431, 443, 443, 457]), "[431]*3+[443]*2+[457]"),
-	("Two Ranges", numpy.array(list(range(461,471))+list(range(479,487))), "[*range(461,471),*range(479,487)]"),
-	("2D array primes", numpy.array([[491, 499, 503], [509, 521, 523]]), "[[491,499,503],[509,521,523]]"),
-	("3D array primes", numpy.array([[[541, 547], [557, 563]], [[569, 571], [577, 587]]]), "[[[541,547],[557,563]],[[569,571],[577,587]]]"),
-], ids=lambda x: x if isinstance(x, str) else "")
-def testAutoDecodingRLE(description: str, value_arrayTarget: NDArray[numpy.integer[Any]], expected: str) -> None:
-	"""Test autoDecodingRLE with various input arrays."""
-	standardizedEqualTo(expected, autoDecodingRLE, value_arrayTarget)
+
+if sys.version_info < (3, 14):
+	@pytest.mark.parametrize("description,value_arrayTarget,expected", [
+		("One range", numpy.array(list(range(50,60))), "[*range(50,60)]"),
+		("Value, range", numpy.array([123]+list(range(71,81))), "[123,*range(71,81)]"),
+		("range, value", numpy.array(list(range(91,97))+[101]), "[*range(91,97),101]"),
+		("Value, range, value", numpy.array([151]+list(range(163,171))+[181]), "[151,*range(163,171),181]"),
+		("Repeat values", numpy.array([191, 191, 191]), "[191]*3"),
+		("Value with repeat", numpy.array([211, 223, 223, 223]), "[211]+[223]*3"),
+		("Range with repeat", numpy.array(list(range(251,257))+[271, 271, 271]), "[*range(251,257)]+[271]*3"),
+		("Value, range, repeat", numpy.array([281]+list(range(291,297))+[307, 307]), "[281,*range(291,297)]+[307]*2"),
+		("repeat, value", numpy.array([313, 313, 313, 331, 331, 349]), "[313]*3+[331]*2+[349]"),
+		("repeat, range", numpy.array([373, 373, 373]+list(range(383,389))), "[373]*3+[*range(383,389)]"),
+		("repeat, range, value", numpy.array(7*[401]+list(range(409,415))+[421]), "[401]*7+[*range(409,415),421]"),
+		("Repeated primes", numpy.array([431, 431, 431, 443, 443, 457]), "[431]*3+[443]*2+[457]"),
+		("Two Ranges", numpy.array(list(range(461,471))+list(range(479,487))), "[*range(461,471),*range(479,487)]"),
+		("2D array primes", numpy.array([[491, 499, 503], [509, 521, 523]]), "[[491,499,503],[509,521,523]]"),
+		("3D array primes", numpy.array([[[541, 547], [557, 563]], [[569, 571], [577, 587]]]), "[[[541,547],[557,563]],[[569,571],[577,587]]]"),
+	], ids=lambda x: x if isinstance(x, str) else "")
+	def testAutoDecodingRLE(description: str, value_arrayTarget: NDArray[numpy.integer[Any]], expected: str) -> None:
+		"""Test autoDecodingRLE with various input arrays."""
+		standardizedEqualTo(expected, autoDecodingRLE, value_arrayTarget)
 
 # Helper functions for generating RLE test data
 def generateCartesianMapping(dimensions: tuple[int, int], formula: Callable[[int, int], int]) -> NDArray[Any]:
@@ -222,98 +228,98 @@ def generateAlternatingColumns(dimensions: tuple[int, int], blockSize: int = 1)
 
 	return generateCartesianMapping(dimensions, columnFormula)
 
-# Updated test cases for autoDecodingRLE with more realistic data
-@pytest.mark.parametrize("description,value_arrayTarget", [
-	# Basic test cases with simple patterns
-	("Simple range", numpy.array(list(range(50,60)))),
-
-	# Chessboard patterns
-	("Small chessboard", generateChessboard((8, 8))),
-
-	# Alternating columns - creates patterns with good RLE opportunities
-	("Alternating columns", generateAlternatingColumns((5, 20), 2)),
-
-	# Step pattern - creates horizontal runs
-	("Step pattern", generateStepPattern((6, 30), 3)),
-
-	# Repeating zones - creates horizontal bands
-	("Repeating zones", generateRepeatingZones((40, 40), 8)),
-
-	# Tile pattern - creates complex repeating regions
-	("Tile pattern", generateTilePattern((15, 15), 5)),
-
-	# Signed quadratic function - includes negative values
-	("Signed quadratic", generateSignedQuadraticFunction((10, 10))),
-
-	# Prime modulo matrix - periodic patterns
-	("Prime modulo", generatePrimeModuloMatrix((12, 12), 7)),
-
-	# Wave pattern - smooth gradients
-	("Wave pattern", generateWavePattern((20, 20))),
-
-	# Spiral pattern - complex pattern with good RLE potential
-	("Spiral pattern", generateSpiralPattern((15, 15), 2)),
-], ids=lambda x: x if isinstance(x, str) else "")
-def testAutoDecodingRLEWithRealisticData(description: str, value_arrayTarget: NDArray[numpy.integer[Any]]) -> None:
-	"""Test autoDecodingRLE with more realistic data patterns."""
-	# Here we test the function behavior rather than expected string output
-	resultRLE = autoDecodingRLE(value_arrayTarget)
-
-	# Test that the result is a valid string
-	assert isinstance(resultRLE, str)
-
-	# Test that the result contains the expected syntax elements
-	assert "[" in resultRLE, f"Result should contain list syntax: {resultRLE}"
-	assert "]" in resultRLE, f"Result should contain list syntax: {resultRLE}"
-
-	# Check that the result is more compact than the raw string representation
-	rawStrLength = len(str(value_arrayTarget.tolist()))
-	encodedLength = len(resultRLE)
-	assert encodedLength <= rawStrLength, f"Encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"
-
-@pytest.mark.parametrize("description,addSpaces", [
-	("With spaces", True),
-	("Without spaces", False),
-], ids=lambda x: x if isinstance(x, str) else "")
-def testAutoDecodingRLEWithSpaces(description: str, addSpaces: bool) -> None:
-	"""Test that the addSpaces parameter affects the internal comparison logic.
-
-	Note: addSpaces doesn't directly change the output format, it just changes
-	the comparison when measuring the length of the string representation.
-	The feature exists because `ast` inserts spaces in its string representation.
-	"""
-	# Create a pattern that has repeated sequences to trigger the RLE logic
-	arrayTarget = generateRepeatingZones((10, 10), 2)
-
-	# Test both configurations
-	resultWithSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=addSpaces)
-	resultNoSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=False)
-
-	# When addSpaces=True, the internal length comparisons change
-	# but the actual output format doesn't necessarily differ
-	# Just verify the function runs without errors in both cases
-	assert isinstance(resultWithSpacesFlag, str)
-	assert isinstance(resultNoSpacesFlag, str)
-
-def testAutoDecodingRLELargeCartesianMapping() -> None:
-	"""Test autoDecodingRLE with a large (100x100) cartesian mapping."""
-	dimensions = (100, 100)
-
-	# Generate a large cartesian mapping with a complex pattern
-	def complexFormula(x: int, y: int) -> int:
-		return ((x * 17) % 11 + (y * 13) % 7) % 10
-
-	arrayMapping = generateCartesianMapping(dimensions, complexFormula)
-
-	# Verify the function works with large arrays
-	resultRLE = autoDecodingRLE(arrayMapping)
-
-	# The result should be a valid string representation
-	assert isinstance(resultRLE, str)
-	assert "[" in resultRLE
-	assert "]" in resultRLE
-
-	# The RLE encoding should be more compact than the raw representation
-	rawStrLength = len(str(arrayMapping.tolist()))
-	encodedLength = len(resultRLE)
-	assert encodedLength <= rawStrLength, f"RLE encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"
+if sys.version_info < (3, 14):
+	@pytest.mark.parametrize("description,value_arrayTarget", [
+		# Basic test cases with simple patterns
+		("Simple range", numpy.array(list(range(50,60)))),
+
+		# Chessboard patterns
+		("Small chessboard", generateChessboard((8, 8))),
+
+		# Alternating columns - creates patterns with good RLE opportunities
+		("Alternating columns", generateAlternatingColumns((5, 20), 2)),
+
+		# Step pattern - creates horizontal runs
+		("Step pattern", generateStepPattern((6, 30), 3)),
+
+		# Repeating zones - creates horizontal bands
+		("Repeating zones", generateRepeatingZones((40, 40), 8)),
+
+		# Tile pattern - creates complex repeating regions
+		("Tile pattern", generateTilePattern((15, 15), 5)),
+
+		# Signed quadratic function - includes negative values
+		("Signed quadratic", generateSignedQuadraticFunction((10, 10))),
+
+		# Prime modulo matrix - periodic patterns
+		("Prime modulo", generatePrimeModuloMatrix((12, 12), 7)),
+
+		# Wave pattern - smooth gradients
+		("Wave pattern", generateWavePattern((20, 20))),
+
+		# Spiral pattern - complex pattern with good RLE potential
+		("Spiral pattern", generateSpiralPattern((15, 15), 2)),
+	], ids=lambda x: x if isinstance(x, str) else "")
+	def testAutoDecodingRLEWithRealisticData(description: str, value_arrayTarget: NDArray[numpy.integer[Any]]) -> None:
+		"""Test autoDecodingRLE with more realistic data patterns."""
+		# Here we test the function behavior rather than expected string output
+		resultRLE = autoDecodingRLE(value_arrayTarget)
+
+		# Test that the result is a valid string
+		assert isinstance(resultRLE, str)
+
+		# Test that the result contains the expected syntax elements
+		assert "[" in resultRLE, f"Result should contain list syntax: {resultRLE}"
+		assert "]" in resultRLE, f"Result should contain list syntax: {resultRLE}"
+
+		# Check that the result is more compact than the raw string representation
+		rawStrLength = len(str(value_arrayTarget.tolist()))
+		encodedLength = len(resultRLE)
+		assert encodedLength <= rawStrLength, f"Encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"
+
+	@pytest.mark.parametrize("description,addSpaces", [
+		("With spaces", True),
+		("Without spaces", False),
+	], ids=lambda x: x if isinstance(x, str) else "")
+	def testAutoDecodingRLEWithSpaces(description: str, addSpaces: bool) -> None:
+		"""Test that the addSpaces parameter affects the internal comparison logic.
+
+		Note: addSpaces doesn't directly change the output format, it just changes
+		the comparison when measuring the length of the string representation.
+		The feature exists because `ast` inserts spaces in its string representation.
+		"""
+		# Create a pattern that has repeated sequences to trigger the RLE logic
+		arrayTarget = generateRepeatingZones((10, 10), 2)
+
+		# Test both configurations
+		resultWithSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=addSpaces)
+		resultNoSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=False)
+
+		# When addSpaces=True, the internal length comparisons change
+		# but the actual output format doesn't necessarily differ
+		# Just verify the function runs without errors in both cases
+		assert isinstance(resultWithSpacesFlag, str)
+		assert isinstance(resultNoSpacesFlag, str)
+
+	def testAutoDecodingRLELargeCartesianMapping() -> None:
+		"""Test autoDecodingRLE with a large (100x100) cartesian mapping."""
+		dimensions = (100, 100)
+
+		# Generate a large cartesian mapping with a complex pattern
+		def complexFormula(x: int, y: int) -> int:
+			return ((x * 17) % 11 + (y * 13) % 7) % 10
+
+		arrayMapping = generateCartesianMapping(dimensions, complexFormula)
+
+		# Verify the function works with large arrays
+		resultRLE = autoDecodingRLE(arrayMapping)
+
+		# The result should be a valid string representation
+		assert isinstance(resultRLE, str)
+		assert "[" in resultRLE
+		assert "]" in resultRLE
+
+		# The RLE encoding should be more compact than the raw representation
+		rawStrLength = len(str(arrayMapping.tolist()))
+		encodedLength = len(resultRLE)
+		assert encodedLength <= rawStrLength, f"RLE encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"

{huntermakespy-0.1.2 → huntermakespy-0.2.0/hunterMakesPy}/tests/test_filesystemToolkit.py

@@ -1,6 +1,6 @@
 # pyright: standard
 from hunterMakesPy import importLogicalPath2Identifier, importPathFilename2Identifier, makeDirsSafely, writeStringToHere
-from tests.conftest import uniformTestFailureMessage
+from hunterMakesPy.tests.conftest import uniformTestFailureMessage
 import io
 import math
 import os
@@ -31,7 +31,10 @@ def testImportLogicalPath2Identifier(moduleName: str, identifier: str, expectedT
 	imported = importLogicalPath2Identifier(moduleName, identifier)
 	assert isinstance(imported, expectedType), uniformTestFailureMessage(expectedType, type(imported), "testImportLogicalPath2Identifier", (moduleName, identifier))
 
-@pytest.mark.parametrize( "source, identifier, expected", [ ("def fibonacciNumber():\n    return 13\n", "fibonacciNumber", 13), ("prime = 17\n", "prime", 17), ] )
+@pytest.mark.parametrize(
+	"source, identifier, expected"
+	, [("def fibonacciNumber():\n    return 13\n", "fibonacciNumber", 13)
+	, ("prime = 17\n", "prime", 17)])
 def testImportPathFilename2Identifier(tmp_path: pathlib.Path, source: str, identifier: str, expected: object) -> None:
 	filePath = tmp_path / "moduleTest.py"
 	filePath.write_text(source)

huntermakespy-0.1.2/hunterMakesPy/pytestForYourUse.py → huntermakespy-0.2.0/hunterMakesPy/tests/test_parseParameters.py

@@ -1,13 +1,13 @@
-"""Pytest tests you can use in your package to test some hunterMakesPy functions.
-
-Each function in this module returns a list of test functions that can be used with `pytest.parametrize`.
-"""
+# pyright: standard
 from collections.abc import Callable, Iterable, Iterator
 from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from typing import Any, NoReturn
+from typing import Any, NoReturn, ParamSpec, TypeVar
 from unittest.mock import Mock, patch
 import pytest
 
+parameters = ParamSpec('parameters')
+returnType = TypeVar('returnType')
+
 def PytestFor_defineConcurrencyLimit(callableToTest: Callable[..., int] = defineConcurrencyLimit, cpuCount: int = 8) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
 	"""Return a list of test functions to validate concurrency limit behavior.
 
@@ -325,3 +325,15 @@ def PytestFor_oopsieKwargsie(callableToTest: Callable[[str], bool | None | str]
 		('testReturnsOriginalString', testReturnsOriginalString),
 		('testHandlesNonStringObjects', testHandlesNonStringObjects)
 	]
+
+@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_defineConcurrencyLimit())
+def testConcurrencyLimit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	aPytest(*arguments, **keywordArguments)
+
+@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_intInnit())
+def testIntInnit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	aPytest(*arguments, **keywordArguments)
+
+@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_oopsieKwargsie())
+def testOopsieKwargsie(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
+	aPytest(*arguments, **keywordArguments)

{huntermakespy-0.1.2 → huntermakespy-0.2.0}/hunterMakesPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.1.2
+Version: 0.2.0
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
@@ -32,7 +33,7 @@ License-File: LICENSE
 Requires-Dist: charset_normalizer
 Requires-Dist: more_itertools
 Requires-Dist: numpy
-Requires-Dist: python_minifier
+Requires-Dist: python_minifier; python_version < "3.14"
 Provides-Extra: development
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"

{huntermakespy-0.1.2 → huntermakespy-0.2.0}/hunterMakesPy.egg-info/SOURCES.txt

@@ -15,9 +15,9 @@ hunterMakesPy.egg-info/SOURCES.txt
 hunterMakesPy.egg-info/dependency_links.txt
 hunterMakesPy.egg-info/requires.txt
 hunterMakesPy.egg-info/top_level.txt
-tests/__init__.py
-tests/conftest.py
-tests/test_coping.py
-tests/test_dataStructures.py
-tests/test_filesystemToolkit.py
-tests/test_parseParameters.py
+hunterMakesPy/tests/__init__.py
+hunterMakesPy/tests/conftest.py
+hunterMakesPy/tests/test_coping.py
+hunterMakesPy/tests/test_dataStructures.py
+hunterMakesPy/tests/test_filesystemToolkit.py
+hunterMakesPy/tests/test_parseParameters.py

{huntermakespy-0.1.2 → huntermakespy-0.2.0}/hunterMakesPy.egg-info/requires.txt

@@ -1,6 +1,8 @@
 charset_normalizer
 more_itertools
 numpy
+
+[:python_version < "3.14"]
 python_minifier
 
 [development]

{huntermakespy-0.1.2 → huntermakespy-0.2.0}/hunterMakesPy.egg-info/top_level.txt

@@ -1,4 +1,3 @@
 citations
 dist
 hunterMakesPy
-tests

{huntermakespy-0.1.2 → huntermakespy-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hunterMakesPy"
-version = "0.1.2"
+version = "0.2.0"
 description = "Easy Python functions making making functional Python functions easier."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -40,6 +40,7 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Programming Language :: Python :: Implementation :: CPython",
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: Utilities",
@@ -50,7 +51,7 @@ dependencies = [
   "charset_normalizer",
   "more_itertools",
   "numpy",
-  "python_minifier",
+  "python_minifier; python_version < '3.14'",
 ]
 optional-dependencies = { development = [
   "mypy",
@@ -75,15 +76,16 @@ run = { branch = true, concurrency = [
   "multiprocessing",
 ], data_file = "tests/coverage/.coverage", omit = [
   "tests/*",
+  "hunterMakesPy/tests/*",
+  "hunterMakesPy/pytestForYourUse.py",
 ], parallel = true, source = [
   ".",
 ] }
-xml = { output = "tests/coverage/coverage.xml" }
 
 [tool.pytest.ini_options]
 addopts = ["--color=auto"]
 log_auto_indent = true
-testpaths = ["tests"]
+testpaths = ["hunterMakesPy/tests"]
 
 [tool.setuptools]
 package-data = { "*" = ["py.typed"] }

huntermakespy-0.1.2/hunterMakesPy/dataStructures.py

@@ -1,265 +0,0 @@
-"""Provides utilities for string extraction from nested data structures and merges multiple dictionaries containing lists into one dictionary."""
-
-from collections.abc import Iterator, Mapping
-from numpy import integer
-from numpy.typing import NDArray
-from typing import Any
-import more_itertools
-import python_minifier
-import re as regex
-
-def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool = False) -> str:  # noqa: C901, PLR0915
-	"""Transform a NumPy array into a compact, self-decoding run-length encoded string representation.
-
-	This function converts a NumPy array into a string that, when evaluated as Python code,
-	recreates the original array structure. The function employs two compression strategies:
-	1. Python's `range` syntax for consecutive integer sequences
-	2. Multiplication syntax for repeated elements
-
-	The resulting string representation is designed to be both human-readable and space-efficient,
-	especially for large cartesian mappings with repetitive patterns. When this string is used
-	as a data source, Python will automatically decode it into Python `list`, which if used as an
-	argument to `numpy.array()`, will recreate the original array structure.
-
-	Parameters
-	----------
-	arrayTarget : NDArray[integer[Any]]
-		(array2target) The NumPy array to be encoded.
-	assumeAddSpaces : bool = False
-		(assume2add2spaces) Affects internal length comparison during compression decisions.
-		This parameter doesn't directly change output format but influences whether
-		`range` or multiplication syntax is preferred in certain cases. The parameter
-		exists because the Abstract Syntax Tree (AST) inserts spaces in its string
-		representation.
-
-	Returns
-	-------
-	rleString : str
-		(rle2string) A string representation of the array using run-length encoding that,
-		when evaluated as Python code, reproduces the original array structure.
-
-	Notes
-	-----
-	The "autoDecoding" feature means that the string representation evaluates directly
-	to the desired data structure without explicit decompression steps.
-
-	"""
-	def sliceNDArrayToNestedLists(arraySlice: NDArray[integer[Any]]) -> Any:
-		def getLengthOption(optionAsStr: str) -> int:
-			"""`assumeAddSpaces` characters: `,` 1; `]*` 2."""
-			return assumeAddSpaces * (optionAsStr.count(',') + optionAsStr.count(']*') * 2) + len(optionAsStr)
-
-		if arraySlice.ndim > 1:
-			axisOfOperation = 0
-			return [sliceNDArrayToNestedLists(arraySlice[index]) for index in range(arraySlice.shape[axisOfOperation])]
-		if arraySlice.ndim == 1:
-			arraySliceAsList: list[int | range] = []
-			cache_consecutiveGroup_addMe: dict[Iterator[Any], list[int] | list[range]] = {}
-			for consecutiveGroup in more_itertools.consecutive_groups(arraySlice.tolist()):
-				if consecutiveGroup in cache_consecutiveGroup_addMe:
-					addMe = cache_consecutiveGroup_addMe[consecutiveGroup]
-				else:
-					ImaSerious: list[int] = list(consecutiveGroup)
-					ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
-					ImaRangeAsStr = python_minifier.minify(str(ImaRange)).replace('range(0,', 'range(').replace('range', '*range')
-
-					option1 = ImaRange
-					option1AsStr = ImaRangeAsStr
-					option2 = ImaSerious
-					option2AsStr = None
-
-					# alpha, potential function
-					option1AsStr = option1AsStr or python_minifier.minify(str(option1))
-					lengthOption1 = getLengthOption(option1AsStr)
-
-					option2AsStr = option2AsStr or python_minifier.minify(str(option2))
-					lengthOption2 = getLengthOption(option2AsStr)
-
-					if lengthOption1 < lengthOption2:
-						addMe = option1
-					else:
-						addMe = option2
-
-					cache_consecutiveGroup_addMe[consecutiveGroup] = addMe
-
-				arraySliceAsList += addMe
-
-			listRangeAndTuple: list[int | range | tuple[int | range, int]] = []
-			cache_malkovichGrouped_addMe: dict[tuple[int | range, int], list[tuple[int | range, int]] | list[int | range]] = {}
-			for malkovichGrouped in more_itertools.run_length.encode(arraySliceAsList):
-				if malkovichGrouped in cache_malkovichGrouped_addMe:
-					addMe = cache_malkovichGrouped_addMe[malkovichGrouped]
-				else:
-					lengthMalkovich = malkovichGrouped[-1]
-					malkovichAsList = list(more_itertools.run_length.decode([malkovichGrouped]))
-					malkovichMalkovich = f"[{malkovichGrouped[0]}]*{lengthMalkovich}"
-
-					option1 = [malkovichGrouped]
-					option1AsStr = malkovichMalkovich
-					option2 = malkovichAsList
-					option2AsStr = None
-
-					# beta, potential function
-					option1AsStr = option1AsStr or python_minifier.minify(str(option1))
-					lengthOption1 = getLengthOption(option1AsStr)
-
-					option2AsStr = option2AsStr or python_minifier.minify(str(option2))
-					lengthOption2 = getLengthOption(option2AsStr)
-
-					if lengthOption1 < lengthOption2:
-						addMe = option1
-					else:
-						addMe = option2
-
-					cache_malkovichGrouped_addMe[malkovichGrouped] = addMe
-
-				listRangeAndTuple += addMe
-
-			return listRangeAndTuple
-		return arraySlice
-
-	arrayAsNestedLists = sliceNDArrayToNestedLists(arrayTarget)
-
-	arrayAsStr = python_minifier.minify(str(arrayAsNestedLists))
-
-	patternRegex = regex.compile(
-		"(?<!rang)(?:"
-		# Pattern 1: Comma ahead, bracket behind  # noqa: ERA001
-		"(?P<joinAhead>,)\\((?P<malkovich>\\d+),(?P<multiply>\\d+)\\)(?P<bracketBehind>])|"
-		# Pattern 2: Bracket or start ahead, comma behind  # noqa: ERA001
-		"(?P<bracketOrStartAhead>\\[|^.)\\((?P<malkovichMalkovich>\\d+),(?P<multiplyIDK>\\d+)\\)(?P<joinBehind>,)|"
-		# Pattern 3: Bracket ahead, bracket behind  # noqa: ERA001
-		"(?P<bracketAhead>\\[)\\((?P<malkovichMalkovichMalkovich>\\d+),(?P<multiply_whatever>\\d+)\\)(?P<bracketBehindBracketBehind>])|"
-		# Pattern 4: Comma ahead, comma behind  # noqa: ERA001
-		"(?P<joinAheadJoinAhead>,)\\((?P<malkovichMalkovichMalkovichMalkovich>\\d+),(?P<multiplyOrSomething>\\d+)\\)(?P<joinBehindJoinBehind>,)"
-		")"
-	)
-
-	def replacementByContext(match: regex.Match[str]) -> str:
-		"""Generate replacement string based on context patterns."""
-		elephino = match.groupdict()
-		joinAhead = elephino.get('joinAhead') or elephino.get('joinAheadJoinAhead')
-		malkovich = elephino.get('malkovich') or elephino.get('malkovichMalkovich') or elephino.get('malkovichMalkovichMalkovich') or elephino.get('malkovichMalkovichMalkovichMalkovich')
-		multiply = elephino.get('multiply') or elephino.get('multiplyIDK') or elephino.get('multiply_whatever') or elephino.get('multiplyOrSomething')
-		joinBehind = elephino.get('joinBehind') or elephino.get('joinBehindJoinBehind')
-
-		replaceAhead = "]+[" if joinAhead == "," else "["
-
-		replaceBehind = "+[" if joinBehind == "," else ""
-
-		return f"{replaceAhead}{malkovich}]*{multiply}{replaceBehind}"
-
-	arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
-	arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
-
-	# Replace `range(0,stop)` syntax with `range(stop)` syntax.  # noqa: ERA001
-	# Add unpack operator `*` for automatic decoding when evaluated.
-	return arrayAsStr.replace('range(0,', 'range(').replace('range', '*range')
-
-def stringItUp(*scrapPile: Any) -> list[str]:  # noqa: C901
-	"""Convert, if possible, every element in the input data structure to a string.
-
-	Order is not preserved or readily predictable.
-
-	Parameters
-	----------
-	*scrapPile : Any
-		(scrap2pile) One or more data structures to unpack and convert to strings.
-
-	Returns
-	-------
-	listStrungUp : list[str]
-		(list2strung2up) A `list` of string versions of all convertible elements.
-
-	"""
-	scrap = None
-	listStrungUp: list[str] = []
-
-	def drill(KitKat: Any) -> None:  # noqa: C901, PLR0912
-		match KitKat:
-			case str():
-				listStrungUp.append(KitKat)
-			case bool() | bytearray() | bytes() | complex() | float() | int() | memoryview() | None:
-				listStrungUp.append(str(KitKat)) # pyright: ignore [reportUnknownArgumentType]
-			case dict():
-				for broken, piece in KitKat.items(): # pyright: ignore [reportUnknownVariableType]
-					drill(broken)
-					drill(piece)
-			case list() | tuple() | set() | frozenset() | range():
-				for kit in KitKat: # pyright: ignore [reportUnknownVariableType]
-					drill(kit)
-			case _:
-				if hasattr(KitKat, '__iter__'):  # Unpack other iterables
-					for kat in KitKat:
-						drill(kat)
-				else:
-					try:
-						sharingIsCaring = 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."
-						pass
-					except:
-						print(f"\nWoah! I received '{repr(KitKat)}'.\nTheir report card says, 'Plays well with others: Needs improvement.'\n")  # noqa: RUF010, T201
-						raise
-	try:
-		for scrap in scrapPile:
-			drill(scrap)
-	except RecursionError:
-		listStrungUp.append(repr(scrap))
-	return listStrungUp
-
-def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[str, list[Any] | set[Any] | tuple[Any, ...]], destroyDuplicates: bool = False, reorderLists: bool = False, killErroneousDataTypes: bool = False) -> dict[str, list[Any]]:
-	"""Merge multiple dictionaries containing `list` into a single dictionary.
-
-	With options to handle duplicates, `list` ordering, and erroneous data types.
-
-	Parameters
-	----------
-	*dictionaryLists : Mapping[str, list[Any] | set[Any] | tuple[Any, ...]]
-		(dictionary2lists) Variable number of dictionaries to be merged. If only one dictionary is passed, it will be processed based on the provided options.
-	destroyDuplicates : bool = False
-		(destroy2duplicates) If `True`, removes duplicate elements from the `list`. Defaults to `False`.
-	reorderLists : bool = False
-		(reorder2lists) If `True`, sorts the `list`. Defaults to `False`.
-	killErroneousDataTypes : bool = False
-		(kill2erroneous2data2types) If `True`, skips dictionary keys or dictionary values that cause a `TypeError` during merging. Defaults to `False`.
-
-	Returns
-	-------
-	ePluribusUnum : dict[str, list[Any]]
-		(e2pluribus2unum) A single dictionary with merged `list` based on the provided options. If only one dictionary is passed,
-		it will be cleaned up based on the options.
-
-	Notes
-	-----
-	The returned value, `ePluribusUnum`, is a so-called primitive dictionary (`dict`). Furthermore, every dictionary key is a
-	so-called primitive string (cf. `str()`) and every dictionary value is a so-called primitive `list` (`list`). If
-	`dictionaryLists` has other data types, the data types 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.
-
-	"""
-	ePluribusUnum: dict[str, list[Any]] = {}
-
-	for dictionaryListTarget in dictionaryLists:
-		for keyName, keyValue in dictionaryListTarget.items():
-			try:
-				ImaStr = str(keyName)
-				ImaList = list(keyValue)
-				ePluribusUnum.setdefault(ImaStr, []).extend(ImaList)
-			except TypeError:
-				if killErroneousDataTypes:
-					continue
-				else:
-					raise
-
-	if destroyDuplicates:
-		for ImaStr, ImaList in ePluribusUnum.items():
-			ePluribusUnum[ImaStr] = list(dict.fromkeys(ImaList))
-	if reorderLists:
-		for ImaStr, ImaList in ePluribusUnum.items():
-			ePluribusUnum[ImaStr] = sorted(ImaList)
-
-	return ePluribusUnum

huntermakespy-0.1.2/tests/test_parseParameters.py

@@ -1,21 +0,0 @@
-# pyright: standard
-from collections.abc import Callable
-from hunterMakesPy.pytestForYourUse import (
-	PytestFor_defineConcurrencyLimit, PytestFor_intInnit, PytestFor_oopsieKwargsie)
-from typing import ParamSpec, TypeVar
-import pytest
-
-parameters = ParamSpec('parameters')
-returnType = TypeVar('returnType')
-
-@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_defineConcurrencyLimit())
-def testConcurrencyLimit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
-	aPytest(*arguments, **keywordArguments)
-
-@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_intInnit())
-def testIntInnit(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
-	aPytest(*arguments, **keywordArguments)
-
-@pytest.mark.parametrize("nameOfTest,aPytest", PytestFor_oopsieKwargsie())
-def testOopsieKwargsie(nameOfTest: str, aPytest: Callable[parameters, returnType], *arguments: parameters.args, **keywordArguments: parameters.kwargs) -> None:
-	aPytest(*arguments, **keywordArguments)