hunterMakesPy 0.2.2__tar.gz → 0.3.0__tar.gz

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

@@ -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 → huntermakespy-0.3.0}/README.md

@@ -119,13 +119,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 → huntermakespy-0.3.0}/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-0.2.2 → huntermakespy-0.3.0}/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.3.0/hunterMakesPy/dataStructures.py

@@ -0,0 +1,273 @@
+"""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."""
+	# 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.3.0}/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.