hunterMakesPy 0.5.1__tar.gz → 0.5.2__tar.gz

{huntermakespy-0.5.1/hunterMakesPy.egg-info → huntermakespy-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.5.1
+Version: 0.5.2
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License-Expression: CC-BY-NC-4.0

{huntermakespy-0.5.1 → huntermakespy-0.5.2}/humpy_cytoolz/recipes.pyi

@@ -10,6 +10,26 @@ def countby[V](key: Any, seq: Iterable[Sequence[V] | Mapping[Any, V]]) -> dict[V
 def countby[T, K, V]( key: Callable[[T], K] | Any, seq: Iterable[T] | Iterable[Sequence[V] | Mapping[Any, V]] ) -> dict[K, int] | dict[V, int]: ...
 
 class partitionby[T](Iterator[tuple[T, ...]]):
+	"""Partition a sequence according to a function
+
+	Partition `s` into a sequence of lists such that, when traversing
+	`s`, every time the output of `func` changes a new list is started
+	and that and subsequent items are collected into that list.
+
+	>>> is_space = lambda c: c == " "
+	>>> list(partitionby(is_space, "I have space"))
+	[('I',), (' ',), ('h', 'a', 'v', 'e'), (' ',), ('s', 'p', 'a', 'c', 'e')]
+
+	>>> is_large = lambda x: x > 10
+	>>> list(partitionby(is_large, [1, 2, 1, 99, 88, 33, 99, -1, 5]))
+	[(1, 2, 1), (99, 88, 33, 99), (-1, 5)]
+
+	See Also
+	--------
+		partition
+		groupby
+		itertools.groupby
+	"""
 	def __init__(self, func: Callable[[T], Any], seq: Iterable[T]) -> None: ...
 	def __iter__(self) -> partitionby[T]: ...
 	def __next__(self) -> tuple[T, ...]: ...

{huntermakespy-0.5.1 → huntermakespy-0.5.2}/hunterMakesPy/dataStructures.py

@@ -33,6 +33,7 @@ from collections.abc import Mapping
 from humpy_cytoolz.functoolz import identity
 from humpy_cytoolz.recipes import partitionby
 from hunterMakesPy import Ordinals
+from more_itertools import consecutive_groups
 from numpy import integer
 from numpy.typing import NDArray
 from typing import Any, cast
@@ -76,88 +77,67 @@ def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool
 
 	The encoded string uses only builtins — no imports are needed to decode it.
 	"""
-	def measurerCalculatesAdjustedLength(string: str) -> int:
-		"""`assumeAddSpaces` characters: `,` 1; `]*` 2."""
-		return len(string) + assumeAddSpaces * (string.count(',') + string.count(']*') * 2)
-
-	# TODO there is only ONE call to this. Refactor to inline it and remove the function definition.
-	def encoderConvertsTokenToString(token: int | tuple[int, int]) -> str:
-		string: str = str(token)
-		if isinstance(token, tuple):
-			rangeStart, rangeEnd = token
-			if rangeStart == 0:
-				string = f"*range({rangeEnd})"
-			else:
-				string = f"*range({rangeStart},{rangeEnd})"
-		return string
-
-	def encoderTransformsOneDimensionalSequenceToString(listIntegers: list[int]) -> str:
-		stringRepresentingArray: str = '[]'
-
-		if listIntegers:
-			listTokens: list[int | tuple[int, int]] = []
-			index: int = 0
-			countIntegers: int = len(listIntegers)
-
-			while index < countIntegers:
-				countConsecutive: int = 1
-				while (index + countConsecutive < countIntegers) and (listIntegers[index + countConsecutive] == listIntegers[index] + countConsecutive):
-					countConsecutive += 1
-
-				integerStart: int = listIntegers[index]
-				integerEnd: int = integerStart + countConsecutive
-				stringRangeSyntax: str = ''
-				if integerStart == 0:
-					stringRangeSyntax = f"*range({integerEnd})"
-				else:
-					stringRangeSyntax = f"*range({integerStart},{integerEnd})"
-				stringCommaSeparated: str = ','.join(str(integerStart + offset) for offset in range(countConsecutive))
-
-				if measurerCalculatesAdjustedLength(stringRangeSyntax) < measurerCalculatesAdjustedLength(stringCommaSeparated):
-					listTokens.append((integerStart, integerEnd))
-				else:
-					for indexOffset in range(countConsecutive):
-						listTokens.append(integerStart + indexOffset)  # noqa: PERF401
-				index += countConsecutive
+	def encodeByRecursion(arraySlice: NDArray[integer[Any]]) -> str:
+		if arraySlice.ndim == 0:
+			return str(int(arraySlice))
+		if arraySlice.ndim == 1:
+			return encodeListAsString(arraySlice.tolist())
+		return '[' + ','.join(map(encodeByRecursion, arraySlice)) + ']'
 
-			listSegments: list[str] = []
-			listBuffer: list[str] = []
+	def encodeListAsString(listIntegers: list[int]) -> str:
+		listTokens: list[str] = []
 
-			for groupTokens in partitionby(identity, listTokens):
-				listGroup: list[int | tuple[int, int]] = list(groupTokens)
-				tokenActive: int | tuple[int, int] = listGroup[0]
-				countRepetitions: int = len(listGroup)
+		for integersConsecutive in consecutive_groups(listIntegers):
+			tupleIntegersConsecutive: tuple[int, ...] = tuple(integersConsecutive)
+			integersConsecutiveLength: int = len(tupleIntegersConsecutive)
 
-				stringTokenActive: str = encoderConvertsTokenToString(tokenActive)
+			if integersConsecutiveLength == 1:
+				listTokens.append(str(tupleIntegersConsecutive[0]))
+			else:
+				start: int = tupleIntegersConsecutive[0]
+				stop: int = start + integersConsecutiveLength
+				if start == 0:
+					startAs_str: str = ''
+				else:
+					startAs_str = f"{start},"
+				stringRangeSyntax: str = f"*range({startAs_str}{stop})"
 
-				if 1 < countRepetitions:
-					stringMultiplicationSyntax: str = f"[{stringTokenActive}]*{countRepetitions}"
-					stringListSyntax: str = "[" + ",".join([stringTokenActive] * countRepetitions) + "]"
-					if measurerCalculatesAdjustedLength(stringMultiplicationSyntax) < measurerCalculatesAdjustedLength(stringListSyntax):
-						if listBuffer:
-							listSegments.append('[' + ','.join(listBuffer) + ']')
-							listBuffer = []
-						listSegments.append(stringMultiplicationSyntax)
-						continue
+				stringCommaSeparated: str = ','.join(map(str, tupleIntegersConsecutive))
 
-				listBuffer.extend([stringTokenActive] * countRepetitions)
+				if measureStringLength(stringRangeSyntax) < measureStringLength(stringCommaSeparated):
+					listTokens.append(stringRangeSyntax)
+				else:
+					listTokens.append(stringCommaSeparated)
+
+		listSegments: list[str] = []
+		listBuffer: list[str] = []
+
+		for tokensIdentical in partitionby(identity, listTokens):
+			tokenAs_str: str = tokensIdentical[0]
+			countRepetitions: int = len(tokensIdentical)
+
+			if 1 < countRepetitions:
+				stringMultiplicationSyntax: str = f"[{tokenAs_str}]*{countRepetitions}"
+				stringListSyntax: str = "[" + ",".join([tokenAs_str] * countRepetitions) + "]"
+				if measureStringLength(stringMultiplicationSyntax) < measureStringLength(stringListSyntax):
+					if listBuffer:
+						listSegments.append('[' + ','.join(listBuffer) + ']')
+						listBuffer = []
+					listSegments.append(stringMultiplicationSyntax)
+					continue
 
-			if listBuffer:
-				listSegments.append('[' + ','.join(listBuffer) + ']')
+			listBuffer.extend([tokenAs_str] * countRepetitions)
 
-			if listSegments:
-				stringRepresentingArray = '+'.join(listSegments)
+		if listBuffer:
+			listSegments.append('[' + ','.join(listBuffer) + ']')
 
-		return stringRepresentingArray
+		return '+'.join(listSegments)
 
-	def encoderTransformsArrayRecursively(arraySlice: NDArray[integer[Any]]) -> str:
-		if arraySlice.ndim == 0:
-			return str(int(arraySlice))
-		if arraySlice.ndim == 1:
-			return encoderTransformsOneDimensionalSequenceToString(arraySlice.tolist())
-		return '[' + ','.join(encoderTransformsArrayRecursively(arraySlice[indexRow]) for indexRow in range(arraySlice.shape[0])) + ']'
+	def measureStringLength(string: str) -> int:
+		"""`assumeAddSpaces` characters: `,` 1; `]*` 2."""
+		return len(string) + assumeAddSpaces * (string.count(',') + string.count(']*') * 2)
 
-	return encoderTransformsArrayRecursively(arrayTarget)
+	return encodeByRecursion(arrayTarget)
 
 def stringItUp(*scrapPile: Any) -> list[str]:
 	"""Convert, if possible, every element in the input data structure to a string.

{huntermakespy-0.5.1 → huntermakespy-0.5.2}/hunterMakesPy/semiotics.py

@@ -1,18 +1,15 @@
 """Express semantic intent through named constants and ANSI color codes.
 
-(AI generated docstring)
+You can use this module to replace numeric literals with semantically meaningful identifiers and
+apply colored terminal output using high-contrast ANSI escape sequences [1]. The module provides
+semantic constants for directional iteration, boundary inclusion, indexing convention adjustments,
+and error state signaling, along with terminal color formatting utilities.
 
-You can use this module to replace numeric literals with semantically meaningful identifiers
-and apply colored terminal output using high-contrast ANSI escape sequences [1]. The module
-provides semantic constants for directional iteration, boundary inclusion, indexing
-convention adjustments, and error state signaling, along with terminal color formatting
-utilities.
-
-The semantic constants make code intent explicit by replacing ambiguous numeric literals like
-`-1`, `1`, and `31212012` with descriptive identifiers such as `decreasing`, `inclusive`,
-`zeroIndexed`, and `errorL33T`. The ANSI color utilities provide escape sequences for
-high-contrast color combinations selected through visibility research [2], enabling clear
-terminal output during debugging and logging operations.
+The semantic constants make code intent explicit by replacing ambiguous numeric literals like `-1`,
+`1`, and `31212012` with descriptive identifiers such as `decreasing`, `inclusive`, `zeroIndexed`,
+and `errorL33T`. The ANSI color utilities provide escape sequences for high-contrast color
+combinations selected through visibility research [2], enabling clear terminal output during
+debugging and logging operations.
 
 Contents
 --------
@@ -47,8 +44,6 @@ from typing import NamedTuple
 decreasing: int = -1
 """Express descending iteration or a reverse direction.
 
-(AI generated docstring)
-
 The identifier `decreasing` holds the value `-1` and serves as a semantic replacement for
 numeric literals in contexts where direction or ordering matters. You can use `decreasing`
 as an addend to adjust boundary values, as a multiplicand to reverse sign or direction,
@@ -108,26 +103,22 @@ References
 errorL33T: int = 31212012
 """Signal an error state with a visually distinctive numeric value.
 
-(AI generated docstring)
+The identifier `errorL33T` holds the value `31212012` and serves as a semantic replacement for
+typical error values such as `-1`. You can use `errorL33T` wherever an error sentinel value appears
+but where the meaning "error state" is more important than the specific numeric value. The value
+`31212012` spells "ERROR" in leetspeak [1], making `errorL33T` more visually distinctive during
+debugging than common error values like `-1`.
 
-The identifier `errorL33T` holds the value `31212012` and serves as a semantic replacement
-for typical error values such as `-1`. You can use `errorL33T` wherever an error sentinel
-value appears but where the meaning "error state" is more important than the specific
-numeric value. The value `31212012` spells "ERROR" in leetspeak [1], making `errorL33T`
-more visually distinctive during debugging than common error values like `-1`.
+You can use `errorL33T` directly as a positive value to signal an invalid or uninitialized state. You
+can use `-errorL33T` when a negative value provides a stronger visual signal or when the domain
+expects negative error indicators. The leetspeak encoding makes `errorL33T` immediately recognizable
+in debugger output, log files, or printed state, reducing the risk of overlooking error conditions
+that might be missed with generic values like `-1`.
 
-You can use `errorL33T` directly as a positive value to signal an invalid or uninitialized
-state. You can use `-errorL33T` when a negative value provides a stronger visual signal
-or when the domain expects negative error indicators. The leetspeak encoding makes
-`errorL33T` immediately recognizable in debugger output, log files, or printed state,
-reducing the risk of overlooking error conditions that might be missed with generic
-values like `-1`.
-
-In rare cases when code execution does not raise `Exception` [2] but produces incorrect
-output, seeing `31212012` or `-31212012` in the output provides a stronger diagnostic
-signal than `-1` or other conventional error values. The distinctive value helps identify
-which variables hold error states without requiring careful inspection of every numeric
-field.
+In rare cases when code execution does not raise `Exception` [2] but produces incorrect output,
+seeing `31212012` or `-31212012` in the output provides a stronger diagnostic signal than `-1` or
+other conventional error values. The distinctive value helps identify which variables hold error
+states without requiring careful inspection of every numeric field.
 
 Examples
 --------
@@ -165,27 +156,24 @@ References
 inclusive: int = 1
 """Express inclusion (or exclusion) of a boundary value.
 
-(AI generated docstring)
-
-The identifier `inclusive` holds the value `1` and serves as a semantic replacement for
-the numeric literal `1` when adjusting boundary computations. You can use `inclusive` to
-convert Python's default half-open interval semantics `[start, stop)` into closed intervals
-`[start, stop]` by adding `inclusive` to the upper bound. You can also use `- inclusive`
-to signal explicit exclusion of a boundary value.
+The identifier `inclusive` holds the value `1` and serves as a semantic replacement for the numeric
+literal `1` when adjusting boundary computations. You can use `inclusive` to convert Python's default
+half-open interval semantics `[start, stop)` into closed intervals `[start, stop]` by adding
+`inclusive` to the upper bound. You can also use `- inclusive` to signal explicit exclusion of a
+boundary value.
 
-You can use `inclusive` wherever `1` would appear but where the meaning "include this
-boundary" or "extend by one position" is more important than the specific numeric value.
-Using `inclusive` makes the code's intent explicit: the adjustment exists to change interval
-semantics, not to perform arbitrary arithmetic.
+You can use `inclusive` wherever `1` would appear but where the meaning "include this boundary" or
+"extend by one position" is more important than the specific numeric value. Using `inclusive` makes
+the code's intent explicit: the adjustment exists to change interval semantics, not to perform
+arbitrary arithmetic.
 
-Common contexts include: `range` objects [1], `slice` objects [2], sequence indexing,
-and any function that accepts boundary parameters with half-open semantics (such as
-`random.randrange` [3], `numpy.arange` [4], or `pandas.RangeIndex` [5]).
+Common contexts include: `range` objects [1], `slice` objects [2], sequence indexing, and any
+function that accepts boundary parameters with half-open semantics (such as `random.randrange` [3],
+`numpy.arange` [4], or `pandas.RangeIndex` [5]).
 
 Many functions in Python packages use half-open intervals by default. For example,
-`random.randrange(start, stop)` [3] excludes `stop`, while `random.randint(a, b)` [3]
-includes `b`. You can use `inclusive` to make the adjustment explicit when working with
-half-open functions:
+`random.randrange(start, stop)` [3] excludes `stop`, while `random.randint(a, b)` [3] includes `b`.
+You can use `inclusive` to make the adjustment explicit when working with half-open functions:
 
 - `range(1, lastValue + inclusive)` includes `lastValue` in the iteration.
 - `slice(start, stop + inclusive)` includes the element at index `stop`.
@@ -199,9 +187,9 @@ You can use `inclusive` to extend `range` [1] objects to include the final value
 >>> for leaf1ndex in range(1, leavesTotal + inclusive):
 ...     processLeaf(leaf1ndex)
 
-Without `inclusive`, `range(1, leavesTotal)` would stop before processing the leaf at
-index `leavesTotal`. Adding `inclusive` ensures the loop processes all leaves from
-`1` through `leavesTotal`.
+Without `inclusive`, `range(1, leavesTotal)` would stop before processing the leaf at index
+`leavesTotal`. Adding `inclusive` ensures the loop processes all leaves from `1` through
+`leavesTotal`.
 
 You can use `inclusive` in nested `range` [1] objects:
 
@@ -227,9 +215,9 @@ You can use `- inclusive` to signal explicit exclusion of a boundary:
 >>> for pile in filter(filterPredicate, range(0, pile_k - inclusive)):
 ...     processPile(pile)
 
-In this example, `pile_k - inclusive` explicitly excludes the pile at index `pile_k` from
-the range. Filters or predicates that accept inclusive upper bounds (such as `between`-style
-functions) may require subtracting `inclusive` to express exclusive boundaries.
+In this example, `pile_k - inclusive` explicitly excludes the pile at index `pile_k` from the range.
+Filters or predicates that accept inclusive upper bounds (such as `between`-style functions) may
+require subtracting `inclusive` to express exclusive boundaries.
 
 You can combine `inclusive` with other semantic constants:
 
@@ -261,8 +249,6 @@ References
 zeroIndexed: int = 1
 """Express that the adjustment to a value is due to zero-based indexing.
 
-(AI generated docstring)
-
 The identifier `zeroIndexed` holds the value `1` and serves as a semantic replacement
 for the numeric literal `1` when converting between zero-based indexing (Python's default)
 and one-based indexing (common in mathematical notation, human-readable numbering, and
@@ -340,27 +326,22 @@ References
 ansiColorReset: str = '\x1b[0m'
 """Reset terminal text color and background to default settings.
 
-(AI generated docstring)
-
-The identifier `ansiColorReset` holds the ANSI escape sequence [1] `\x1b[0m` that resets
-terminal foreground and background colors to their default values. You can use
-`ansiColorReset` after printing colored text to ensure subsequent output appears in the
-terminal's default color scheme.
+The identifier `ansiColorReset` holds the ANSI escape sequence [1] `\x1b[0m` that resets terminal
+foreground and background colors to their default values. You can use `ansiColorReset` after printing
+colored text to ensure subsequent output appears in the terminal's default color scheme.
 
-ANSI escape sequences [1] allow programs to control terminal display attributes by
-embedding special character sequences in output text. The sequence `\x1b[0m` (ESC[0m)
-resets all text attributes, including color, weight, and style, returning the terminal
-to its default state.
+ANSI escape sequences [1] allow programs to control terminal display attributes by embedding special
+character sequences in output text. The sequence `\x1b[0m` (ESC[0m) resets all text attributes,
+including color, weight, and style, returning the terminal to its default state.
 
-You can concatenate `ansiColorReset` with output strings or write `ansiColorReset` as
-a separate operation after colored text. Failing to reset colors causes subsequent
-output to inherit the previous color settings, which can make output difficult to read
-if default-colored text appears against a colored background.
+You can concatenate `ansiColorReset` with output strings or write `ansiColorReset` as a separate
+operation after colored text. Failing to reset colors causes subsequent output to inherit the
+previous color settings, which can make output difficult to read if default-colored text appears
+against a colored background.
 
-Most modern terminal emulators support ANSI escape sequences [1] on all platforms,
-including Windows Terminal, macOS Terminal, and Linux terminals. Legacy Windows console
-applications may require enabling ANSI support through Windows API calls or environment
-variables.
+Most modern terminal emulators support ANSI escape sequences [1] on all platforms, including Windows
+Terminal, macOS Terminal, and Linux terminals. Legacy Windows console applications may require
+enabling ANSI support through Windows API calls or environment variables.
 
 Examples
 --------
@@ -390,30 +371,27 @@ References
 class AnsiColors(NamedTuple):
 	r"""Provide high-contrast ANSI color combinations for terminal output.
 
-	(AI generated docstring)
+	You can use this class to access ANSI escape sequences [1] for displaying colored text in
+	terminal emulators. Each attribute holds an escape sequence that sets both foreground and
+	background colors simultaneously. The color combinations were selected through research into
+	high-contrast color visibility [2] to maximize readability across different terminal color
+	schemes and viewing conditions.
 
-	You can use this class to access ANSI escape sequences [1] for displaying colored
-	text in terminal emulators. Each attribute holds an escape sequence that sets both
-	foreground and background colors simultaneously. The color combinations were selected
-	through research into high-contrast color visibility [2] to maximize readability
-	across different terminal color schemes and viewing conditions.
-
-	ANSI escape sequences [1] control terminal display attributes by embedding special
-	character sequences in output text. The sequences in `AnsiColors` use the format
-	`\\x1b[foreground;backgroundm` where foreground and background are numeric color codes.
-	Each sequence sets both colors simultaneously to ensure sufficient contrast regardless
-	of the terminal's default color scheme.
+	ANSI escape sequences [1] control terminal display attributes by embedding special character
+	sequences in output text. The sequences in `AnsiColors` use the format
+	`\\x1b[foreground;backgroundm` where foreground and background are numeric color codes. Each
+	sequence sets both colors simultaneously to ensure sufficient contrast regardless of the
+	terminal's default color scheme.
 
 	You can access color combinations through attribute names following the pattern
-	`ForegroundOnBackground`, such as `BlackOnCyan` or `WhiteOnRed`. The colors were
-	chosen to provide strong visual contrast while remaining comfortable to read during
-	extended debugging sessions. Always use `ansiColorReset` [3] after colored output
-	to return the terminal to default colors.
+	`ForegroundOnBackground`, such as `BlackOnCyan` or `WhiteOnRed`. The colors were chosen to
+	provide strong visual contrast while remaining comfortable to read during extended debugging
+	sessions. Always use `ansiColorReset` [3] after colored output to return the terminal to default
+	colors.
 
-	The `NamedTuple` [4] base class makes `AnsiColors` immutable and provides both
-	attribute access and sequence indexing. You can access colors by name
-	(`ansiColors.GreenOnBlack`) or by index (`ansiColors[0]`), enabling dynamic color
-	selection based on computed indices.
+	The `NamedTuple` [4] base class makes `AnsiColors` immutable and provides both attribute access
+	and sequence indexing. You can access colors by name (`ansiColors.GreenOnBlack`) or by index
+	(`ansiColors[0]`), enabling dynamic color selection based on computed indices.
 
 	Attributes
 	----------
@@ -477,9 +455,8 @@ class AnsiColors(NamedTuple):
 	>>> colorIndex = int(identifier, 36) % len(ansiColors)
 	>>> sys.stdout.write(f"{ansiColors[colorIndex]}{identifier}{ansiColorReset}")
 
-	This pattern provides consistent color assignment for identifiers based on their
-	string representation, making repeated identifiers appear in the same color across
-	multiple runs.
+	This pattern provides consistent color assignment for identifiers based on their string
+	representation, making repeated identifiers appear in the same color across multiple runs.
 
 	You can combine multiple colored segments in output:
 
@@ -495,7 +472,7 @@ class AnsiColors(NamedTuple):
 	[2] Color contrast - Wikipedia
 		https://en.wikipedia.org/wiki/Contrast_(vision)#Color_contrast
 	[3] ansiColorReset
-		Internal package reference
+
 	[4] Built-in Types - `typing.NamedTuple` (Python documentation)
 		https://docs.python.org/3/library/typing.html#typing.NamedTuple
 	"""

{huntermakespy-0.5.1 → huntermakespy-0.5.2/hunterMakesPy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.5.1
+Version: 0.5.2
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License-Expression: CC-BY-NC-4.0

{huntermakespy-0.5.1 → huntermakespy-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hunterMakesPy"
-version = "0.5.1"
+version = "0.5.2"
 description = "Easy Python functions making making functional Python functions easier."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -73,16 +73,6 @@ requires = [
 ]
 build-backend = "setuptools.build_meta"
 
-# [tool.cibuildwheel]
-# test-command = "pytest"
-# test-extras = ["testing"]
-# test-sources = [
-#   "humpy_cytoolz/tests",
-#   "humpy_toolz/sandbox/tests",
-#   "humpy_toolz/tests",
-#   "hunterMakesPy/tests",
-# ]
-
 [tool.coverage]
 report = { exclude_lines = [
   "if TYPE_CHECKING:",