hunterMakesPy 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

hunterMakesPy/__init__.py

@@ -17,13 +17,10 @@ from hunterMakesPy.parseParameters import (defineConcurrencyLimit as defineConcu
 
 from hunterMakesPy.filesystemToolkit import (importLogicalPath2Identifier as importLogicalPath2Identifier,
 	importPathFilename2Identifier as importPathFilename2Identifier, makeDirsSafely as makeDirsSafely,
-	writeStringToHere as writeStringToHere)
+	writePython as writePython, writeStringToHere as writeStringToHere)
 
 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.dataStructures import autoDecodingRLE as autoDecodingRLE
 
 from hunterMakesPy._theSSOT import settingsPackage

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/dataStructures.py

@@ -6,158 +6,163 @@ 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
+def removeExtraWhitespace(text: str) -> str:
+	"""Remove extra whitespace from string representation of Python data structures."""
+	# 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)
 
-						# alpha, potential function
-						option1AsStr = option1AsStr or python_minifier.minify(str(option1))
-						lengthOption1 = getLengthOption(option1AsStr)
+def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool = False) -> str:
+	"""Transform a NumPy array into a compact, self-decoding run-length encoded string representation.
 
-						option2AsStr = option2AsStr or python_minifier.minify(str(option2))
-						lengthOption2 = getLengthOption(option2AsStr)
+	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
 
-						if lengthOption1 < lengthOption2:
-							addMe = option1
-						else:
-							addMe = option2
+	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.
 
-						cache_consecutiveGroup_addMe[consecutiveGroup] = addMe
+	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.
 
-					arraySliceAsList += addMe
+	Notes
+	-----
+	The "autoDecoding" feature means that the string representation evaluates directly
+	to the desired data structure without explicit decompression steps.
 
-				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]
+	"""
+	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:
-						lengthMalkovich = malkovichGrouped[-1]
-						malkovichAsList = list(more_itertools.run_length.decode([malkovichGrouped]))
-						malkovichMalkovich = f"[{malkovichGrouped[0]}]*{lengthMalkovich}"
+						addMe = option2
 
-						option1 = [malkovichGrouped]
-						option1AsStr = malkovichMalkovich
-						option2 = malkovichAsList
-						option2AsStr = None
+					cache_consecutiveGroup_addMe[consecutiveGroup] = addMe
 
-						# beta, potential function
-						option1AsStr = option1AsStr or python_minifier.minify(str(option1))
-						lengthOption1 = getLengthOption(option1AsStr)
+				arraySliceAsList += addMe
 
-						option2AsStr = option2AsStr or python_minifier.minify(str(option2))
-						lengthOption2 = getLengthOption(option2AsStr)
+			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}"
 
-						if lengthOption1 < lengthOption2:
-							addMe = option1
-						else:
-							addMe = option2
+					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
+					cache_malkovichGrouped_addMe[malkovichGrouped] = addMe
 
-					listRangeAndTuple += addMe
+				listRangeAndTuple += addMe
 
-				return listRangeAndTuple
-			return arraySlice
+			return listRangeAndTuple
+		return arraySlice
 
-		arrayAsNestedLists = sliceNDArrayToNestedLists(arrayTarget)
+	arrayAsNestedLists = sliceNDArrayToNestedLists(arrayTarget)
 
-		arrayAsStr = python_minifier.minify(str(arrayAsNestedLists))
+	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>,)"
-			")"
-		)
+	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')
+	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 "["
+		replaceAhead = "]+[" if joinAhead == "," else "["
 
-			replaceBehind = "+[" if joinBehind == "," else ""
+		replaceBehind = "+[" if joinBehind == "," else ""
 
-			return f"{replaceAhead}{malkovich}]*{multiply}{replaceBehind}"
+		return f"{replaceAhead}{malkovich}]*{multiply}{replaceBehind}"
 
-		arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
-		arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
+	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')
+	# 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.

hunterMakesPy/filesystemToolkit.py

@@ -3,8 +3,9 @@
 This module provides basic file I/O utilities such as importing callables from modules, safely creating directories, and writing to files or streams (pipes).
 
 """
-
+from autoflake import fix_code as autoflake_fix_code
 from hunterMakesPy import identifierDotAttribute
+from isort import code as isort_code
 from os import PathLike
 from pathlib import Path, PurePath
 from typing import Any, TYPE_CHECKING, TypeVar
@@ -97,6 +98,59 @@ def makeDirsSafely(pathFilename: Any) -> None:
 		with contextlib.suppress(OSError):
 			Path(pathFilename).parent.mkdir(parents=True, exist_ok=True)
 
+settings_autoflakeDEFAULT: dict[str, list[str] | bool] = {
+	'additional_imports': [],
+	'expand_star_imports': True,
+	'remove_all_unused_imports': True,
+	'remove_duplicate_keys': False,
+	'remove_unused_variables': False,
+}
+
+settings_isortDEFAULT: dict[str, int | str | list[str]] = {
+	"combine_as_imports": True,
+	"force_alphabetical_sort_within_sections": True,
+	"from_first": True,
+	"honor_noqa": True,
+	"indent": "\t",
+	"line_length": 120,
+	"lines_after_imports": 1,
+	"lines_between_types": 0,
+	"multi_line_output": 4,
+	"no_sections": True,
+	"skip": ["__init__.py"], # TODO think
+	"use_parentheses": True,
+}
+
+def writePython(pythonSource: str, pathFilename: PathLike[Any] | PurePath | io.TextIOBase, settings: dict[str, dict[str, Any]] | None = None) -> None:
+	"""Format and write Python source code to a file or text stream.
+
+	(AI generated docstring)
+
+	This function processes Python source code through autoflake and isort formatters before writing to the specified destination.
+	The formatters remove unused imports, sort imports, and apply consistent code style according to the provided or default
+	settings.
+
+	Parameters
+	----------
+	pythonSource : str
+		The Python source code to format and write.
+	pathFilename : PathLike[Any] | PurePath | io.TextIOBase
+		The target destination: either a file path or an open text stream.
+	settings : dict[str, dict[str, Any]] | None = None
+		Configuration for the formatters. Keys are `'autoflake'` and `'isort'`, each mapping to a dictionary of formatter-specific
+		settings. If `None`, default settings are used for both formatters.
+
+	"""
+	if settings is None:
+		settings = {}
+
+	settings_autoflake: dict[str, Any] = settings.get('autoflake', settings_autoflakeDEFAULT)
+	pythonSource = autoflake_fix_code(pythonSource, **settings_autoflake)
+
+	settings_isort: dict[str, Any] = settings.get('isort', settings_isortDEFAULT)
+	pythonSource = isort_code(pythonSource, **settings_isort)
+	writeStringToHere(pythonSource + '\n', pathFilename)
+
 def writeStringToHere(this: str, pathFilename: PathLike[Any] | PurePath | io.TextIOBase) -> None:
 	"""Write a string to a file or text stream.
 

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/tests/test_filesystemToolkit.py

@@ -1,5 +1,6 @@
 # pyright: standard
-from hunterMakesPy import importLogicalPath2Identifier, importPathFilename2Identifier, makeDirsSafely, writeStringToHere
+from hunterMakesPy import (
+	importLogicalPath2Identifier, importPathFilename2Identifier, makeDirsSafely, writePython, writeStringToHere)
 from hunterMakesPy.tests.conftest import standardizedEqualTo
 import io
 import math
@@ -261,3 +262,188 @@ def testImportPathFilename2IdentifierWithValidFileInvalidIdentifier(
 		identifierTarget
 	)
 
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, expectedFormattedContent",
+	[
+		(
+			"import sys\nimport os\nimport math\n\ndef fibonacciFunction():\n    return 13\n",
+			"\ndef fibonacciFunction():\n    return 13\n\n"
+		),
+		(
+			"from pathlib import Path\nimport sys\nimport os\n\ndef primeFunction():\n    return 17\n",
+			"\ndef primeFunction():\n    return 17\n\n"
+		),
+		(
+			"import unused\nimport sys\n\nvalueCardinal = sys.version\n",
+			"import sys\n\nvalueCardinal = sys.version\n\n"
+		),
+		(
+			"import math\n\nvalueFibonacci = math.sqrt(21)\n",
+			"import math\n\nvalueFibonacci = math.sqrt(21)\n\n"
+		),
+	]
+)
+def testWritePythonFormatsAndWritesToFile(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	expectedFormattedContent: str
+) -> None:
+	"""Test that writePython formats Python source code and writes it to files."""
+	pathFilenameTarget = pathTmpTesting / "formattedModule.py"
+	writePython(pythonSourceTarget, pathFilenameTarget)
+
+	assert pathFilenameTarget.exists(), (
+		f"\nTesting: `writePython(..., {pathFilenameTarget})`\n"
+		f"Expected: File {pathFilenameTarget} to exist\n"
+		f"Got: exists={pathFilenameTarget.exists()}"
+	)
+
+	contentActual = pathFilenameTarget.read_text(encoding="utf-8")
+	assert contentActual == expectedFormattedContent, (
+		f"\nTesting: `writePython(...)`\n"
+		f"Expected content:\n{repr(expectedFormattedContent)}\n"
+		f"Got content:\n{repr(contentActual)}"
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, expectedFormattedContent",
+	[
+		(
+			"import sys\nimport unused\n\ndef cardinalFunction():\n    return sys.version\n",
+			"import sys\n\ndef cardinalFunction():\n    return sys.version\n\n"
+		),
+		(
+			"from pathlib import Path\nfrom os import getcwd\nimport math\n\nvalueSequence = getcwd()\n",
+			"from os import getcwd\n\nvalueSequence = getcwd()\n\n"
+		),
+	]
+)
+def testWritePythonFormatsAndWritesToStream(
+	pythonSourceTarget: str,
+	expectedFormattedContent: str
+) -> None:
+	"""Test that writePython formats Python source code and writes it to IO streams."""
+	streamMemory = io.StringIO()
+	writePython(pythonSourceTarget, streamMemory)
+
+	contentActual = streamMemory.getvalue()
+	assert contentActual == expectedFormattedContent, (
+		f"\nTesting: `writePython(..., StringIO)`\n"
+		f"Expected content:\n{repr(expectedFormattedContent)}\n"
+		f"Got content:\n{repr(contentActual)}"
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, settingsCustom, expectedFormattedContent",
+	[
+		(
+			"import math\nimport unused\n\nvalueFibonacci = 34\n\ndef fibonacciFunction():\n    return math.sqrt(13)\n",
+			{'autoflake': {'remove_all_unused_imports': True, 'remove_unused_variables': False}},
+			"import math\n\nvalueFibonacci = 34\n\ndef fibonacciFunction():\n    return math.sqrt(13)\n\n"
+		),
+		(
+			"from pathlib import Path\nimport sys\n\nvaluePrime = Path.cwd()\n",
+			{'isort': {'force_alphabetical_sort_within_sections': False, 'from_first': False}},
+			"from pathlib import Path\n\nvaluePrime = Path.cwd()\n\n"
+		),
+	]
+)
+def testWritePythonWithCustomSettings(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	settingsCustom: dict[str, dict[str, object]],
+	expectedFormattedContent: str
+) -> None:
+	"""Test that writePython respects custom formatter settings."""
+	pathFilenameTarget = pathTmpTesting / "customFormattedModule.py"
+	writePython(pythonSourceTarget, pathFilenameTarget, settingsCustom)
+
+	contentActual = pathFilenameTarget.read_text(encoding="utf-8")
+	assert contentActual == expectedFormattedContent, (
+		f"\nTesting: `writePython(..., custom settings)`\n"
+		f"Expected content:\n{repr(expectedFormattedContent)}\n"
+		f"Got content:\n{repr(contentActual)}"
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget",
+	[
+		"import math\nimport sys\n\nvalueFibonacci = 34\n",
+		"from pathlib import Path\n\nvalueCardinal = 'SW'\n",
+		"def primeFunction():\n    return 37\n",
+	]
+)
+def testWritePythonCreatesNestedDirectories(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str
+) -> None:
+	"""Test that writePython creates nested directories when writing to files."""
+	pathFilenameTarget = pathTmpTesting / "nested" / "directories" / "module.py"
+	writePython(pythonSourceTarget, pathFilenameTarget)
+
+	assert pathFilenameTarget.exists(), (
+		f"\nTesting: `writePython(..., {pathFilenameTarget})`\n"
+		f"Expected: File {pathFilenameTarget} to exist\n"
+		f"Got: exists={pathFilenameTarget.exists()}"
+	)
+
+	assert pathFilenameTarget.parent.exists(), (
+		f"\nTesting: `writePython(..., {pathFilenameTarget})`\n"
+		f"Expected: Parent directory {pathFilenameTarget.parent} to exist\n"
+		f"Got: exists={pathFilenameTarget.parent.exists()}"
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, expectedContainsImport",
+	[
+		("import math\n\nvaluePrime = math.sqrt(41)\n", "import math"),
+		("from os import getcwd\n\nvalueSequence = getcwd()\n", "from os import getcwd"),
+		("import sys\n\nvalueFibonacci = sys.version\n", "import sys"),
+	]
+)
+def testWritePythonPreservesUsedImports(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	expectedContainsImport: str
+) -> None:
+	"""Test that writePython preserves imports that are actually used in the code."""
+	pathFilenameTarget = pathTmpTesting / "preservedImports.py"
+	writePython(pythonSourceTarget, pathFilenameTarget)
+
+	contentActual = pathFilenameTarget.read_text(encoding="utf-8")
+	assert expectedContainsImport in contentActual, (
+		f"\nTesting: `writePython(...)` preserves used imports\n"
+		f"Expected content to contain: {expectedContainsImport}\n"
+		f"Got content:\n{contentActual}"
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, expectedNotContainsImport",
+	[
+		("import math\nimport unused\n\nvaluePrime = 43\n", "import unused"),
+		("from os import getcwd, unused\n\nvalueSequence = getcwd()\n", "unused"),
+		("import sys\nimport collections\n\nvalueFibonacci = sys.version\n", "import collections"),
+	]
+)
+def testWritePythonRemovesUnusedImports(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	expectedNotContainsImport: str
+) -> None:
+	"""Test that writePython removes imports that are not used in the code."""
+	pathFilenameTarget = pathTmpTesting / "removedImports.py"
+	writePython(pythonSourceTarget, pathFilenameTarget)
+
+	contentActual = pathFilenameTarget.read_text(encoding="utf-8")
+	assert expectedNotContainsImport not in contentActual, (
+		f"\nTesting: `writePython(...)` removes unused imports\n"
+		f"Expected content to NOT contain: {expectedNotContainsImport}\n"
+		f"Got content:\n{contentActual}"
+	)
+

{huntermakespy-0.2.2.dist-info → huntermakespy-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.2.2
+Version: 0.3.0
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -9,7 +9,7 @@ Project-URL: Homepage, https://github.com/hunterhogan/hunterMakesPy
 Project-URL: Issues, https://github.com/hunterhogan/hunterMakesPy/issues
 Project-URL: Repository, https://github.com/hunterhogan/hunterMakesPy
 Keywords: attribute loading,concurrency limit,configuration,defensive programming,dictionary merging,directory creation,dynamic import,error propagation,file system utilities,input validation,integer parsing,module loading,nested data structures,package settings,parameter validation,pytest,string extraction,test utilities
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
@@ -30,13 +30,12 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: autoflake
 Requires-Dist: charset_normalizer
+Requires-Dist: isort
 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"
 Requires-Dist: setuptools-scm; extra == "development"
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"
@@ -165,13 +164,4 @@ def test_myFunction(nameOfTest, callablePytest):
 [![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
 [![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
 
-## How to code
-
-Coding One Step at a Time:
-
-0. WRITE CODE.
-1. Don't write stupid code that's hard to revise.
-2. Write good code.
-3. When revising, write better code.
-
 [![CC-BY-NC-4.0](https://github.com/hunterhogan/hunterMakesPy/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

{huntermakespy-0.2.2.dist-info → huntermakespy-0.3.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-hunterMakesPy/__init__.py,sha256=bVF1F2Mdo5AOiioEfxKvNrnsa3vCFI16eMK7Oy5O5TU,1450
+hunterMakesPy/__init__.py,sha256=5UWFiB9YCTei76LfMCYipSFSIMVspw2jhcca_NmynGI,1431
 hunterMakesPy/_theSSOT.py,sha256=lkLOG3oTIWNKD_ULX55chlUGNqCHgqVIrBvolvK1vbQ,153
-hunterMakesPy/coping.py,sha256=covqNFAwkF9gjafrlAvMdtCO8haFsESQBhO-7s68qSg,5581
-hunterMakesPy/dataStructures.py,sha256=Ur2Z4Pytb1Lc5ov8Ag_xm3eii16nJR_yMZzBhbS8vpI,11311
-hunterMakesPy/filesystemToolkit.py,sha256=jd7H5UtrIrPiCYWcvNBNa6DAy-2Ewcf21-jbGXg_IVI,4702
+hunterMakesPy/coping.py,sha256=7NBwaGutEr6Q-2mIz65M69NkrbpG24u1I5HXx6VaAWI,6057
+hunterMakesPy/dataStructures.py,sha256=WC6MO0LjrhCEv0prd5hlC9efG4DuL9lEm-fWlhHUVUw,11509
+hunterMakesPy/filesystemToolkit.py,sha256=loBn6GcScIucrMpjopGdZu6ja3nTkyBfcSiH9_P4cxY,6773
 hunterMakesPy/parseParameters.py,sha256=1mwGNVIZ1x23k_di3lhOhQb8QMXMUCHgt7xw3NRzDXs,11814
 hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hunterMakesPy/pytestForYourUse.py,sha256=GiN1C1gTTM0ZunRPEMnrKlLQLMdH0wF_ZGr_RPgRjjA,500
@@ -10,11 +10,11 @@ hunterMakesPy/theTypes.py,sha256=C2d0uLn1VIx6_2CK41it3IP7iplSQqe51tzWc-RT320,306
 hunterMakesPy/tests/__init__.py,sha256=C_FzfKDi_VrGVxlenWHyOYtKShAKlt3KW14jeRx1mQI,224
 hunterMakesPy/tests/conftest.py,sha256=NZQPRiwvGhP16hJ6WGGm9eKLxfQArYV8E9X12YzSpP0,2827
 hunterMakesPy/tests/test_coping.py,sha256=mH89TUAL6fJanBLlhdVlCNNQqm5OpdcQMP_p5W2JJwo,9860
-hunterMakesPy/tests/test_dataStructures.py,sha256=O4aqzSKg7KfWWVhIewOH0Y8Zj28PbFCb4XX3xhwuFQA,16605
-hunterMakesPy/tests/test_filesystemToolkit.py,sha256=q2voXjCbQPIT8l8VF9iuWX1Bs2ZieABItWoVkITj_fo,8841
+hunterMakesPy/tests/test_dataStructures.py,sha256=OouddHjN-Km26U92jYwnjYeP6_Y2DrJLgq3qD_8GvGw,16393
+hunterMakesPy/tests/test_filesystemToolkit.py,sha256=_CoSMzstJwWZ_tkNyIqclOIIqTaY2tYfUIgxGFfC0Jk,15335
 hunterMakesPy/tests/test_parseParameters.py,sha256=80npsoWcCackjxvoW2dMXMpHeale7fuRXyXp78MibLs,14037
-huntermakespy-0.2.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-huntermakespy-0.2.2.dist-info/METADATA,sha256=s4xUkaMaL_EEx5S0V5YZdV4qyl_ql6dx1Ozgvhf6kRA,6547
-huntermakespy-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-huntermakespy-0.2.2.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
-huntermakespy-0.2.2.dist-info/RECORD,,
+huntermakespy-0.3.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+huntermakespy-0.3.0.dist-info/METADATA,sha256=SNJ2cKtyLw97-NGIsvCQsqllBJ82DW9Ipxntx2Qvmzk,6290
+huntermakespy-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+huntermakespy-0.3.0.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
+huntermakespy-0.3.0.dist-info/RECORD,,