hunterMakesPy 0.1.0__tar.gz → 0.1.2__tar.gz

huntermakespy-0.1.2/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: hunterMakesPy
+Version: 0.1.2
+Summary: Easy Python functions making making functional Python functions easier.
+Author-email: Hunter Hogan <HunterHogan@pm.me>
+License: CC-BY-NC-4.0
+Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: Homepage, https://github.com/hunterhogan/
+Project-URL: Issues, https://github.com/hunterhogan/
+Project-URL: Repository, https://github.com/hunterhogan/
+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: Environment :: Console
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Other Audience
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: charset_normalizer
+Requires-Dist: more_itertools
+Requires-Dist: numpy
+Requires-Dist: python_minifier
+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"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+Dynamic: license-file
+
+# hunterMakesPy
+
+A modular Python toolkit for defensive programming, parameter validation, file system utilities, and flexible data structure manipulation.
+
+[![pip install hunterMakesPy](https://img.shields.io/badge/pip%20install-hunterMakesPy-gray.svg?colorB=3b434b)](https://pypi.org/project/hunterMakesPy/)
+
+## Overview
+
+hunterMakesPy provides utilities for safe error handling, flexible input validation, dynamic module and attribute importing, and merging or transforming complex data structures. The package emphasizes clear identifiers, robust type handling, and reusable components for building reliable Python applications.
+
+## Installation
+
+```bash
+pip install hunterMakesPy
+```
+
+## Defensive Programming
+
+Utilities for handling `None` values and defensive programming patterns.
+
+```python
+from hunterMakesPy import raiseIfNone
+
+# Ensure a function result is not None
+def findConfiguration(configName: str) -> dict[str, str] | None:
+    # ... search logic ...
+    return None
+
+config = raiseIfNone(
+    findConfiguration("database"),
+    "Configuration 'database' is required but not found"
+)
+```
+
+## Parameter Validation
+
+Parameter validation, integer parsing, and concurrency handling.
+
+```python
+from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
+
+# Smart concurrency limit calculation
+cpuLimit = defineConcurrencyLimit(limit=0.75)  # Use 75% of available CPUs
+cpuLimit = defineConcurrencyLimit(limit=True)  # Use exactly 1 CPU
+cpuLimit = defineConcurrencyLimit(limit=4)     # Use exactly 4 CPUs
+
+# Robust integer validation
+validatedIntegers = intInnit([1, "2", 3.0, "4"], "port_numbers")
+
+# String-to-boolean conversion for configuration
+userInput = "True"
+booleanValue = oopsieKwargsie(userInput)  # Returns True
+```
+
+## File System Utilities
+
+Safe file operations and dynamic module importing.
+
+```python
+from hunterMakesPy import (
+    importLogicalPath2Identifier,
+    importPathFilename2Identifier,
+    makeDirsSafely,
+    writeStringToHere
+)
+
+# Dynamic imports
+gcdFunction = importLogicalPath2Identifier("math", "gcd")
+customFunction = importPathFilename2Identifier("path/to/module.py", "functionName")
+
+# Safe file operations
+pathFilename = Path("deep/nested/directory/file.txt")
+writeStringToHere("content", pathFilename)  # Creates directories automatically
+```
+
+## Data Structure Manipulation
+
+Utilities for string extraction, data flattening, and array compression.
+
+```python
+from hunterMakesPy import stringItUp, updateExtendPolishDictionaryLists, autoDecodingRLE
+import numpy
+
+# Extract all strings from nested data structures
+nestedData = {"config": [1, "host", {"port": 8080}], "users": ["alice", "bob"]}
+allStrings = stringItUp(nestedData)  # ['config', 'host', 'port', 'users', 'alice', 'bob']
+
+# Merge dictionaries containing lists
+dictionaryAlpha = {"servers": ["web1", "web2"], "databases": ["db1"]}
+dictionaryBeta = {"servers": ["web3"], "databases": ["db2", "db3"]}
+merged = updateExtendPolishDictionaryLists(dictionaryAlpha, dictionaryBeta, destroyDuplicates=True)
+
+# Compress NumPy arrays with run-length encoding
+arrayData = numpy.array([1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9])
+compressed = autoDecodingRLE(arrayData)  # "[1,*range(2,6)]+[5]*2+[*range(6,10)]"
+```
+
+## Testing
+
+The package includes comprehensive test suites that you can import and run:
+
+```python
+from hunterMakesPy.pytestForYourUse import (
+    PytestFor_defineConcurrencyLimit,
+    PytestFor_intInnit,
+    PytestFor_oopsieKwargsie
+)
+
+# Run tests on the built-in functions
+listOfTests = PytestFor_defineConcurrencyLimit()
+for nameOfTest, callablePytest in listOfTests:
+    callablePytest()
+
+# Or test your own compatible functions
+@pytest.mark.parametrize("nameOfTest,callablePytest",
+                        PytestFor_intInnit(callableToTest=myFunction))
+def test_myFunction(nameOfTest, callablePytest):
+    callablePytest()
+```
+
+## My recovery
+
+[![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.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

huntermakespy-0.1.2/README.md

@@ -0,0 +1,135 @@
+# hunterMakesPy
+
+A modular Python toolkit for defensive programming, parameter validation, file system utilities, and flexible data structure manipulation.
+
+[![pip install hunterMakesPy](https://img.shields.io/badge/pip%20install-hunterMakesPy-gray.svg?colorB=3b434b)](https://pypi.org/project/hunterMakesPy/)
+
+## Overview
+
+hunterMakesPy provides utilities for safe error handling, flexible input validation, dynamic module and attribute importing, and merging or transforming complex data structures. The package emphasizes clear identifiers, robust type handling, and reusable components for building reliable Python applications.
+
+## Installation
+
+```bash
+pip install hunterMakesPy
+```
+
+## Defensive Programming
+
+Utilities for handling `None` values and defensive programming patterns.
+
+```python
+from hunterMakesPy import raiseIfNone
+
+# Ensure a function result is not None
+def findConfiguration(configName: str) -> dict[str, str] | None:
+    # ... search logic ...
+    return None
+
+config = raiseIfNone(
+    findConfiguration("database"),
+    "Configuration 'database' is required but not found"
+)
+```
+
+## Parameter Validation
+
+Parameter validation, integer parsing, and concurrency handling.
+
+```python
+from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
+
+# Smart concurrency limit calculation
+cpuLimit = defineConcurrencyLimit(limit=0.75)  # Use 75% of available CPUs
+cpuLimit = defineConcurrencyLimit(limit=True)  # Use exactly 1 CPU
+cpuLimit = defineConcurrencyLimit(limit=4)     # Use exactly 4 CPUs
+
+# Robust integer validation
+validatedIntegers = intInnit([1, "2", 3.0, "4"], "port_numbers")
+
+# String-to-boolean conversion for configuration
+userInput = "True"
+booleanValue = oopsieKwargsie(userInput)  # Returns True
+```
+
+## File System Utilities
+
+Safe file operations and dynamic module importing.
+
+```python
+from hunterMakesPy import (
+    importLogicalPath2Identifier,
+    importPathFilename2Identifier,
+    makeDirsSafely,
+    writeStringToHere
+)
+
+# Dynamic imports
+gcdFunction = importLogicalPath2Identifier("math", "gcd")
+customFunction = importPathFilename2Identifier("path/to/module.py", "functionName")
+
+# Safe file operations
+pathFilename = Path("deep/nested/directory/file.txt")
+writeStringToHere("content", pathFilename)  # Creates directories automatically
+```
+
+## Data Structure Manipulation
+
+Utilities for string extraction, data flattening, and array compression.
+
+```python
+from hunterMakesPy import stringItUp, updateExtendPolishDictionaryLists, autoDecodingRLE
+import numpy
+
+# Extract all strings from nested data structures
+nestedData = {"config": [1, "host", {"port": 8080}], "users": ["alice", "bob"]}
+allStrings = stringItUp(nestedData)  # ['config', 'host', 'port', 'users', 'alice', 'bob']
+
+# Merge dictionaries containing lists
+dictionaryAlpha = {"servers": ["web1", "web2"], "databases": ["db1"]}
+dictionaryBeta = {"servers": ["web3"], "databases": ["db2", "db3"]}
+merged = updateExtendPolishDictionaryLists(dictionaryAlpha, dictionaryBeta, destroyDuplicates=True)
+
+# Compress NumPy arrays with run-length encoding
+arrayData = numpy.array([1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9])
+compressed = autoDecodingRLE(arrayData)  # "[1,*range(2,6)]+[5]*2+[*range(6,10)]"
+```
+
+## Testing
+
+The package includes comprehensive test suites that you can import and run:
+
+```python
+from hunterMakesPy.pytestForYourUse import (
+    PytestFor_defineConcurrencyLimit,
+    PytestFor_intInnit,
+    PytestFor_oopsieKwargsie
+)
+
+# Run tests on the built-in functions
+listOfTests = PytestFor_defineConcurrencyLimit()
+for nameOfTest, callablePytest in listOfTests:
+    callablePytest()
+
+# Or test your own compatible functions
+@pytest.mark.parametrize("nameOfTest,callablePytest",
+                        PytestFor_intInnit(callableToTest=myFunction))
+def test_myFunction(nameOfTest, callablePytest):
+    callablePytest()
+```
+
+## My recovery
+
+[![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.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

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

@@ -1,14 +1,22 @@
-"""`import hunterMakesPy as humpy`."""
+"""A modular toolkit for defensive programming, parameter validation, file system utilities, and data structure manipulation.
+
+This package provides:
+- Defensive programming helpers for handling `None` values and error propagation.
+- Parameter and input validation, integer parsing, and concurrency limit utilities.
+- File system and import utilities for safe directory creation and dynamic module/attribute loading.
+- Utilities for string extraction from nested data structures and merging dictionaries of lists.
+
+"""
 from hunterMakesPy.theTypes import identifierDotAttribute as identifierDotAttribute
 
-from hunterMakesPy.coping import raiseIfNone as raiseIfNone
+from hunterMakesPy.coping import PackageSettings as PackageSettings, raiseIfNone as raiseIfNone
 
 from hunterMakesPy.parseParameters import (defineConcurrencyLimit as defineConcurrencyLimit, intInnit as intInnit,
 	oopsieKwargsie as oopsieKwargsie)
 
 from hunterMakesPy.filesystemToolkit import (importLogicalPath2Identifier as importLogicalPath2Identifier,
 	importPathFilename2Identifier as importPathFilename2Identifier, makeDirsSafely as makeDirsSafely,
-    writeStringToHere as writeStringToHere)
+	writeStringToHere as writeStringToHere)
 
 from hunterMakesPy.dataStructures import (autoDecodingRLE as autoDecodingRLE, stringItUp as stringItUp,
 	updateExtendPolishDictionaryLists as updateExtendPolishDictionaryLists)

huntermakespy-0.1.2/hunterMakesPy/_theSSOT.py

@@ -0,0 +1,4 @@
+"""Settings for this package."""
+from hunterMakesPy import PackageSettings
+
+settingsPackage = PackageSettings(identifierPackageFALLBACK="hunterMakesPy")

huntermakespy-0.1.2/hunterMakesPy/coping.py

@@ -0,0 +1,149 @@
+"""Package configuration and defensive programming utilities for Python projects."""
+from importlib.util import find_spec
+from pathlib import Path
+from tomllib import loads as tomllib_loads
+from typing import TYPE_CHECKING, TypeVar
+import dataclasses
+
+if TYPE_CHECKING:
+	from importlib.machinery import ModuleSpec
+
+TypeSansNone = TypeVar('TypeSansNone')
+
+def getIdentifierPackagePACKAGING(identifierPackageFALLBACK: str) -> str:
+	"""Get package name from pyproject.toml or fallback to provided value."""
+	try:
+		return tomllib_loads(Path('pyproject.toml').read_text(encoding='utf-8'))['project']['name']
+	except Exception:  # noqa: BLE001
+		return identifierPackageFALLBACK
+
+def getPathPackageINSTALLING(identifierPackage: str) -> Path:
+	"""Return the root directory of the installed package."""
+	try:
+		moduleSpecification: ModuleSpec | None = find_spec(identifierPackage)
+		if moduleSpecification and moduleSpecification.origin:
+			pathFilename = Path(moduleSpecification.origin)
+			return pathFilename.parent if pathFilename.is_file() else pathFilename
+	except ModuleNotFoundError:
+		pass
+	return Path.cwd()
+
+@dataclasses.dataclass
+class PackageSettings:
+	"""Configuration container for Python package metadata and runtime settings.
+
+	This `class` provides a simple way to store and access basic information about a Python package, It will automatically resolve
+	package identifiers and installation paths if they are not passed to the `class` constructor. Python `dataclasses` are easy to
+	subtype and extend.
+
+	Parameters
+	----------
+	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`.
+	fileExtension : str = '.py'
+		Default file extension.
+
+	Examples
+	--------
+	Automatic package discovery from development environment:
+
+	```python
+	settings = PackageSettings(identifierPackageFALLBACK='cobraPy')
+	# Automatically discovers package name from pyproject.toml
+	# Resolves installation path from package identifier
+	```
+
+	Explicit configuration for specific deployment:
+
+	```python
+	settings = PackageSettings(
+		identifierPackage='cobraPy',
+		pathPackage=Path('/opt/tenEx/packages/cobraPy'),
+		fileExtension='.pyx'
+	)
+	```
+
+	"""
+
+	identifierPackageFALLBACK: dataclasses.InitVar[str] = ''
+	"""Fallback package identifier used during initialization only."""
+	pathPackage: Path = dataclasses.field(default_factory=Path, metadata={'evaluateWhen': 'installing'})
+	"""Absolute path to the installed package."""
+	identifierPackage: str = dataclasses.field(default='', metadata={'evaluateWhen': 'packaging'})
+	"""Name of this package."""
+	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
+	"""Default file extension for files."""
+
+	def __post_init__(self, identifierPackageFALLBACK: str) -> None:
+		"""Initialize computed fields after dataclass initialization."""
+		if not self.identifierPackage and identifierPackageFALLBACK:
+			self.identifierPackage = getIdentifierPackagePACKAGING(identifierPackageFALLBACK)
+		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)
+
+	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.
+
+	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.
+
+	Returns
+	-------
+	returnTarget : TypeSansNone
+		The original `returnTarget` value, guaranteed to not be `None`.
+
+	Raises
+	------
+	ValueError
+		If `returnTarget` is `None`.
+
+	Examples
+	--------
+	Ensure a function result is not `None`:
+
+	```python
+	def findFirstMatch(listItems: list[str], pattern: str) -> str | None:
+		for item in listItems:
+			if pattern in item:
+				return item
+		return None
+
+	listFiles = ['document.txt', 'image.png', 'data.csv']
+	filename = raiseIfNone(findFirstMatch(listFiles, '.txt'))
+	# Returns 'document.txt'
+	```
+
+	Handle dictionary lookups with custom error messages:
+
+	```python
+	configurationMapping = {'host': 'localhost', 'port': 8080}
+	host = raiseIfNone(configurationMapping.get('host'),
+					"Configuration must include 'host' setting")
+	# Returns 'localhost'
+
+	# This would raise ValueError with custom message:
+	# database = raiseIfNone(configurationMapping.get('database'),
+	#                       "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
+
+	"""
+	if returnTarget is None:
+		message = errorMessage or 'A function unexpectedly returned `None`. Hint: look at the traceback immediately before `raiseIfNone`.'
+		raise ValueError(message)
+	return returnTarget

{huntermakespy-0.1.0 → huntermakespy-0.1.2}/hunterMakesPy/dataStructures.py

@@ -46,7 +46,7 @@ def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool
 	"""
 	def sliceNDArrayToNestedLists(arraySlice: NDArray[integer[Any]]) -> Any:
 		def getLengthOption(optionAsStr: str) -> int:
-			# `assumeAddSpaces` characters: `,` 1; `]*` 2  # noqa: ERA001
+			"""`assumeAddSpaces` characters: `,` 1; `]*` 2."""
 			return assumeAddSpaces * (optionAsStr.count(',') + optionAsStr.count(']*') * 2) + len(optionAsStr)
 
 		if arraySlice.ndim > 1:
@@ -125,29 +125,29 @@ def autoDecodingRLE(arrayTarget: NDArray[integer[Any]], *, assumeAddSpaces: bool
 	patternRegex = regex.compile(
 		"(?<!rang)(?:"
 		# Pattern 1: Comma ahead, bracket behind  # noqa: ERA001
-		"(?P<joinAhead>,)\\((?P<malkovich>\\d+),(?P<multiple>\\d+)\\)(?P<bracketBehind>])|"
+		"(?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<multiple_fml>\\d+)\\)(?P<joinBehind>,)|"
+		"(?P<bracketOrStartAhead>\\[|^.)\\((?P<malkovichMalkovich>\\d+),(?P<multiplyIDK>\\d+)\\)(?P<joinBehind>,)|"
 		# Pattern 3: Bracket ahead, bracket behind  # noqa: ERA001
-		"(?P<bracketAhead>\\[)\\((?P<malkovichmalkovichmalkovich>\\d+),(?P<multiple_whatever>\\d+)\\)(?P<bracketBehindbracketBehind>])|"
+		"(?P<bracketAhead>\\[)\\((?P<malkovichMalkovichMalkovich>\\d+),(?P<multiply_whatever>\\d+)\\)(?P<bracketBehindBracketBehind>])|"
 		# Pattern 4: Comma ahead, comma behind  # noqa: ERA001
-		"(?P<joinAhead_prayharder>,)\\((?P<malkovichmalkovichmalkovichmalkovich>\\d+),(?P<multiple_prayharder>\\d+)\\)(?P<joinBehind_prayharder>,)"
+		"(?P<joinAheadJoinAhead>,)\\((?P<malkovichMalkovichMalkovichMalkovich>\\d+),(?P<multiplyOrSomething>\\d+)\\)(?P<joinBehindJoinBehind>,)"
 		")"
 	)
 
 	def replacementByContext(match: regex.Match[str]) -> str:
 		"""Generate replacement string based on context patterns."""
-		yourIdentifiersSuck = match.groupdict()
-		joinAhead = yourIdentifiersSuck.get('joinAhead') or yourIdentifiersSuck.get('joinAhead_prayharder')
-		malkovich = yourIdentifiersSuck.get('malkovich') or yourIdentifiersSuck.get('malkovichmalkovich') or yourIdentifiersSuck.get('malkovichmalkovichmalkovich') or yourIdentifiersSuck.get('malkovichmalkovichmalkovichmalkovich')
-		multiple = yourIdentifiersSuck.get('multiple') or yourIdentifiersSuck.get('multiple_fml') or yourIdentifiersSuck.get('multiple_whatever') or yourIdentifiersSuck.get('multiple_prayharder')
-		joinBehind = yourIdentifiersSuck.get('joinBehind') or yourIdentifiersSuck.get('joinBehind_prayharder')
+		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}]*{multiple}{replaceBehind}"
+		return f"{replaceAhead}{malkovich}]*{multiply}{replaceBehind}"
 
 	arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
 	arrayAsStr = patternRegex.sub(replacementByContext, arrayAsStr)
@@ -249,7 +249,7 @@ def updateExtendPolishDictionaryLists(*dictionaryLists: Mapping[str, list[Any] |
 				ImaStr = str(keyName)
 				ImaList = list(keyValue)
 				ePluribusUnum.setdefault(ImaStr, []).extend(ImaList)
-			except TypeError:  # noqa: PERF203
+			except TypeError:
 				if killErroneousDataTypes:
 					continue
 				else:

{huntermakespy-0.1.0 → huntermakespy-0.1.2}/hunterMakesPy/filesystemToolkit.py

@@ -1,7 +1,6 @@
 """File system and module import utilities.
 
-This module provides basic file I/O utilities such as writing tabular data to files, computing canonical relative paths, importing
-callables from modules, and safely creating directories.
+This module provides basic file I/O utilities such as importing callables from modules, and safely creating directories.
 
 """