hunterMakesPy 0.2.2__tar.gz → 0.2.4__tar.gz

{huntermakespy-0.2.2 → huntermakespy-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.2.2
+Version: 0.2.4
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -33,7 +33,6 @@ License-File: LICENSE
 Requires-Dist: charset_normalizer
 Requires-Dist: more_itertools
 Requires-Dist: numpy
-Requires-Dist: python_minifier; python_version < "3.14"
 Provides-Extra: development
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"

{huntermakespy-0.2.2 → huntermakespy-0.2.4}/hunterMakesPy/coping.py

@@ -36,14 +36,14 @@ class PackageSettings:
 	package identifiers and installation paths if they are not passed to the `class` constructor. Python `dataclasses` are easy to
 	subtype and extend.
 
-	Parameters
+	Attributes
 	----------
 	identifierPackageFALLBACK : str = ''
 		Fallback package identifier used only during initialization when automatic discovery fails.
-	pathPackage : Path = Path()
-		Absolute path to the installed package directory. Automatically resolved from `identifierPackage` if not provided.
 	identifierPackage : str = ''
-		Canonical name of the package. Automatically extracted from `pyproject.toml`.
+		Canonical name of the package. Automatically extracted from "pyproject.toml".
+	pathPackage : Path = getPathPackageINSTALLING(identifierPackage)
+		Absolute path to the installed package directory. Automatically resolved from `identifierPackage` if not provided.
 	fileExtension : str = '.py'
 		Default file extension.
 
@@ -85,34 +85,39 @@ class PackageSettings:
 		if self.pathPackage == Path() and self.identifierPackage:
 			self.pathPackage = getPathPackageINSTALLING(self.identifierPackage)
 
-def raiseIfNone(returnTarget: TypeSansNone | None, errorMessage: str | None = None) -> TypeSansNone:
-	"""Raise a `ValueError` if the target value is `None`, otherwise return the value: tell the type checker that the return value is not `None`.
-
-	(AI generated docstring)
+def raiseIfNone(expression: TypeSansNone | None, errorMessage: str | None = None) -> TypeSansNone:
+	"""Convert the `expression` return annotation from '`cerPytainty | None`' to '`cerPytainty`' because `expression` cannot be `None`; `raise` an `Exception` if you're wrong.
 
-	This is a defensive programming function that converts unexpected `None` values into explicit errors with context. It is useful for asserting that functions that might return `None` have actually returned a meaningful value.
+	The Python interpreter evaluates `expression` to a value: think of a function call or an attribute access. You can use
+	`raiseIfNone` for fail early defensive programming. I use it, however, to cure type-checker-nihilism: that's when "or `None`"
+	return types cause your type checker to repeatedly say, "You can't do that because the value might be `None`."
 
 	Parameters
 	----------
-	returnTarget : TypeSansNone | None
-		The value to check for `None`. If not `None`, this value is returned unchanged.
-	errorMessage : str | None = None
-		Custom error message to include in the `ValueError`. If `None`, a default message with debugging hints is used.
+	expression : TypeSansNone | None
+		Python code with a return type that is a `union` of `None` and `TypeSansNone`, which is a stand-in for one or more other types.
+	errorMessage : str | None = 'A function unexpectedly returned `None`. Hint: look at the traceback immediately before `raiseIfNone`.'
+		Custom error message for the `ValueError` `Exception` if `expression` is `None`.
 
 	Returns
 	-------
-	returnTarget : TypeSansNone
-		The original `returnTarget` value, guaranteed to not be `None`.
+	contentment : TypeSansNone
+		The value returned by `expression`, but guaranteed to not be `None`.
 
 	Raises
 	------
 	ValueError
-		If `returnTarget` is `None`.
+		If the value returned by `expression` is `None`.
 
 	Examples
 	--------
-	Ensure a function result is not `None`:
+	Basic usage with attribute access:
+	```python
+	annotation = raiseIfNone(ast_arg.annotation)
+	# Raises ValueError if ast_arg.annotation is None
+	```
 
+	Function return value validation:
 	```python
 	def findFirstMatch(listItems: list[str], pattern: str) -> str | None:
 		for item in listItems:
@@ -122,28 +127,27 @@ def raiseIfNone(returnTarget: TypeSansNone | None, errorMessage: str | None = No
 
 	listFiles = ['document.txt', 'image.png', 'data.csv']
 	filename = raiseIfNone(findFirstMatch(listFiles, '.txt'))
-	# Returns 'document.txt'
+	# Returns 'document.txt' when match exists
 	```
 
-	Handle dictionary lookups with custom error messages:
-
+	Dictionary value retrieval with custom message:
 	```python
 	configurationMapping = {'host': 'localhost', 'port': 8080}
 	host = raiseIfNone(configurationMapping.get('host'),
 					"Configuration must include 'host' setting")
-	# Returns 'localhost'
+	# Returns 'localhost' when key exists
 
 	# This would raise ValueError with custom message:
 	# database = raiseIfNone(configurationMapping.get('database'),
-	#                       "Configuration must include 'database' setting")
+	#                      "Configuration must include 'database' setting")
 	```
 
 	Thanks
 	------
-	sobolevn, https://github.com/sobolevn, for the seed of the function. https://github.com/python/typing/discussions/1997#discussioncomment-13108399
+	sobolevn, https://github.com/sobolevn, for the seed of this function. https://github.com/python/typing/discussions/1997#discussioncomment-13108399
 
 	"""
-	if returnTarget is None:
+	if expression is None:
 		message = errorMessage or 'A function unexpectedly returned `None`. Hint: look at the traceback immediately before `raiseIfNone`.'
 		raise ValueError(message)
-	return returnTarget
+	return expression

huntermakespy-0.2.4/hunterMakesPy/dataStructures.py

@@ -0,0 +1,278 @@
+"""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
+
+def removeExtraWhitespace(text: str) -> str:
+	"""Remove extra whitespace from string representation of Python data structures.
+
+	This function replaces python_minifier.minify() for the specific use case of
+	minimizing string representations of lists, tuples, ranges, etc. It removes
+	spaces after commas, around brackets and parentheses.
+	"""
+	# Remove spaces after commas
+	text = regex.sub(r',\s+', ',', text)
+	# Remove spaces after opening brackets/parens
+	text = regex.sub(r'([\[\(])\s+', r'\1', text)
+	# Remove spaces before closing brackets/parens
+	return regex.sub(r'\s+([\]\)])', r'\1', text)
+
+def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool = False) -> str:
+	"""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 = removeExtraWhitespace(str(ImaRange)).replace('range(0,', 'range(').replace('range', '*range')
+
+					option1 = ImaRange
+					option1AsStr = ImaRangeAsStr
+					option2 = ImaSerious
+					option2AsStr = None
+
+					# alpha, potential function
+					option1AsStr = option1AsStr or removeExtraWhitespace(str(option1))
+					lengthOption1 = getLengthOption(option1AsStr)
+
+					option2AsStr = option2AsStr or removeExtraWhitespace(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 removeExtraWhitespace(str(option1))
+					lengthOption1 = getLengthOption(option1AsStr)
+
+					option2AsStr = option2AsStr or removeExtraWhitespace(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 = removeExtraWhitespace(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]:
+	"""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:
+		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: 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.2.2 → huntermakespy-0.2.4}/hunterMakesPy/tests/test_dataStructures.py

@@ -2,7 +2,7 @@
 from collections.abc import Callable, Iterable, Iterator
 from decimal import Decimal
 from fractions import Fraction
-from hunterMakesPy import stringItUp, updateExtendPolishDictionaryLists
+from hunterMakesPy import autoDecodingRLE, stringItUp, updateExtendPolishDictionaryLists
 from hunterMakesPy.tests.conftest import standardizedEqualTo
 from numpy.typing import NDArray
 from typing import Any, Literal
@@ -11,9 +11,6 @@ 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
 	def __iter__(self) -> Iterator[Any]: return iter(self.items)
@@ -99,27 +96,26 @@ def testUpdateExtendPolishDictionaryLists(description: str, value_dictionaryList
 
 # ruff: noqa: RUF005
 
-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)
+@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]:
@@ -228,98 +224,97 @@ def generateAlternatingColumns(dimensions: tuple[int, int], blockSize: int = 1)
 
 	return generateCartesianMapping(dimensions, columnFormula)
 
-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})"
+@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.2.2 → huntermakespy-0.2.4}/hunterMakesPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.2.2
+Version: 0.2.4
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -33,7 +33,6 @@ License-File: LICENSE
 Requires-Dist: charset_normalizer
 Requires-Dist: more_itertools
 Requires-Dist: numpy
-Requires-Dist: python_minifier; python_version < "3.14"
 Provides-Extra: development
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"

{huntermakespy-0.2.2 → huntermakespy-0.2.4}/hunterMakesPy.egg-info/requires.txt

@@ -2,9 +2,6 @@ charset_normalizer
 more_itertools
 numpy
 
-[:python_version < "3.14"]
-python_minifier
-
 [development]
 mypy
 pyupgrade

{huntermakespy-0.2.2 → huntermakespy-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hunterMakesPy"
-version = "0.2.2"
+version = "0.2.4"
 description = "Easy Python functions making making functional Python functions easier."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -51,7 +51,6 @@ dependencies = [
   "charset_normalizer",
   "more_itertools",
   "numpy",
-  "python_minifier; python_version < '3.14'",
 ]
 optional-dependencies = { development = [
   "mypy",

huntermakespy-0.2.2/hunterMakesPy/dataStructures.py

@@ -1,268 +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 re as regex
-import sys
-
-if sys.version_info < (3, 14):
-	import python_minifier
-
-	def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool = False) -> str:
-		"""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]:
-	"""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:
-		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: 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