hunterMakesPy 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

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

@@ -1,40 +1,4 @@
-"""Primary: settings for this package.
+"""Settings for this package."""
+from hunterMakesPy import PackageSettings
 
-Secondary: settings for manufacturing.
-Tertiary: hardcoded values until I implement a dynamic solution.
-"""
-from importlib.util import find_spec
-from pathlib import Path
-from tomli import loads as tomli_loads
-from typing import TYPE_CHECKING
-import dataclasses
-
-if TYPE_CHECKING:
-	from importlib.machinery import ModuleSpec
-
-try:
-	identifierPackagePACKAGING: str = tomli_loads(Path("pyproject.toml").read_text())["project"]["name"]
-except Exception:  # noqa: BLE001
-	identifierPackagePACKAGING = "hunterMakesPy"
-
-def getPathPackageINSTALLING() -> Path:
-    """Return the root directory of the installed package."""
-    try:
-        moduleSpecification: ModuleSpec | None = find_spec(identifierPackagePACKAGING)
-        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:
-	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
-	"""Default file extension for generated code files."""
-	identifierPackage: str = dataclasses.field(default = identifierPackagePACKAGING, metadata={'evaluateWhen': 'packaging'})
-	"""Name of this package, used for import paths and configuration."""
-	pathPackage: Path = dataclasses.field(default_factory=getPathPackageINSTALLING, metadata={'evaluateWhen': 'installing'})
-	"""Absolute path to the installed package directory."""
-
-settingsPackage = PackageSettings()
+settingsPackage = PackageSettings(identifierPackageFALLBACK="hunterMakesPy")

hunterMakesPy/coping.py

@@ -1,13 +1,89 @@
-"""Utility functions for handling `None` values and coping with common programming patterns.
+"""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
 
-(AI generated docstring)
+if TYPE_CHECKING:
+	from importlib.machinery import ModuleSpec
 
-This module provides helper functions for defensive programming and error handling, particularly for dealing with `None` values that should not occur in correct program flow.
+TypeSansNone = TypeVar('TypeSansNone')
 
-"""
-from typing import TypeVar
+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.
 
-TypeSansNone = TypeVar('TypeSansNone')
+	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`.

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/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.
 
 """
 

huntermakespy-0.1.2.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,20 @@
+hunterMakesPy/__init__.py,sha256=4gIm--UJmlQEhbLCqpiVFM_JVbyfVpvFFAJyMNFHekk,1329
+hunterMakesPy/_theSSOT.py,sha256=lkLOG3oTIWNKD_ULX55chlUGNqCHgqVIrBvolvK1vbQ,153
+hunterMakesPy/coping.py,sha256=covqNFAwkF9gjafrlAvMdtCO8haFsESQBhO-7s68qSg,5581
+hunterMakesPy/dataStructures.py,sha256=znMEnboo2iNXZtQKdmruRrJDEoeTfqoH4-coUDM75g4,11218
+hunterMakesPy/filesystemToolkit.py,sha256=vDYS0Rc1aP7ETLXHKoO3TfOpuwJQFQW2ybwtJNiIIo4,4305
+hunterMakesPy/parseParameters.py,sha256=plrJ4xR1FQnQR9j-oeMAwB2H9r_8QD8OALnw0OH8Kt0,11947
+hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hunterMakesPy/pytestForYourUse.py,sha256=21BI8TXyinf8rMmS6dTsuRMBOOFTcyoG_gD__Gz_e7Q,13288
+hunterMakesPy/theTypes.py,sha256=C2d0uLn1VIx6_2CK41it3IP7iplSQqe51tzWc-RT320,306
+huntermakespy-0.1.2.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=MkNc4Ar6yYrnAok4t1NWsgyOYFDiGo1qwXHyp8ChJf4,1672
+tests/test_coping.py,sha256=MQl0fhdWX2YSFzzjWMThSm_ZSnglE3anSJO2b33typU,9846
+tests/test_dataStructures.py,sha256=VhM3VzG1l8l3Iz1q9sQjpNBQTWSrl4zWbnefsGTccos,16406
+tests/test_filesystemToolkit.py,sha256=jk6Ke0fW6dlHIVyvA1lh7o7_I7DVZr6uMO3s_i43isQ,2445
+tests/test_parseParameters.py,sha256=bHD-O-OyWWwPOx3zvS53pSNPDm3LbFS05N5JcfNCLG4,1137
+huntermakespy-0.1.2.dist-info/METADATA,sha256=b1Xr8jhpu8t-H3BTVQUcCww_gG8q5fcb1REz-8AQbY8,6555
+huntermakespy-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+huntermakespy-0.1.2.dist-info/top_level.txt,sha256=dUy7z3LNO6aqNjPD81tZjE5N9HO70a14Y9lAWjWC2gA,20
+huntermakespy-0.1.2.dist-info/RECORD,,

tests/test_coping.py

@@ -1,4 +1,6 @@
-from hunterMakesPy import raiseIfNone
+from hunterMakesPy import PackageSettings, raiseIfNone
+from hunterMakesPy.coping import getIdentifierPackagePACKAGING, getPathPackageINSTALLING
+from pathlib import Path
 from tests.conftest import uniformTestFailureMessage
 import pytest
 
@@ -54,3 +56,161 @@ def testRaiseIfNonePreservesTypeAnnotations() -> None:
 
     listValue: list[int] = raiseIfNone([29, 31])
     assert isinstance(listValue, list), uniformTestFailureMessage(list, type(listValue), "testRaiseIfNonePreservesTypeAnnotations", listValue)
+
+# Tests for PackageSettings dataclass
+@pytest.mark.parametrize(
+    "identifierPackageFALLBACK, expectedIdentifierPackage",
+    [
+        ("astToolFactory", "hunterMakesPy"),  # Should read from pyproject.toml
+        ("nonExistentPackage", "hunterMakesPy"),  # Should read from pyproject.toml
+        ("customPackage", "hunterMakesPy"),  # Should read from pyproject.toml
+    ]
+)
+def testPackageSettingsWithFallbackUsesProjectToml(identifierPackageFALLBACK: str, expectedIdentifierPackage: str) -> None:
+    """Test that PackageSettings reads package name from pyproject.toml when using fallback."""
+    packageSettings = PackageSettings(identifierPackageFALLBACK)
+    assert packageSettings.identifierPackage == expectedIdentifierPackage, uniformTestFailureMessage(
+        expectedIdentifierPackage, packageSettings.identifierPackage, "PackageSettings fallback", identifierPackageFALLBACK
+    )
+
+@pytest.mark.parametrize(
+    "explicitIdentifierPackage, expectedIdentifierPackage",
+    [
+        ("customPackageName", "customPackageName"),
+        ("fibonacci", "fibonacci"),
+        ("prime", "prime"),
+        ("astToolFactory", "astToolFactory"),
+    ]
+)
+def testPackageSettingsWithExplicitIdentifierPackage(explicitIdentifierPackage: str, expectedIdentifierPackage: str) -> None:
+    """Test that PackageSettings respects explicitly provided identifierPackage."""
+    packageSettings = PackageSettings(identifierPackage=explicitIdentifierPackage)
+    assert packageSettings.identifierPackage == expectedIdentifierPackage, uniformTestFailureMessage(
+        expectedIdentifierPackage, packageSettings.identifierPackage, "PackageSettings explicit identifierPackage", explicitIdentifierPackage
+    )
+
+@pytest.mark.parametrize(
+    "explicitPathPackage, expectedPathPackage",
+    [
+        (Path("C:/fibonacci/path"), Path("C:/fibonacci/path")),
+        (Path("C:/prime/directory"), Path("C:/prime/directory")),
+        (Path("/usr/local/lib/package"), Path("/usr/local/lib/package")),
+        (Path("relative/path"), Path("relative/path")),
+    ]
+)
+def testPackageSettingsWithExplicitPathPackage(explicitPathPackage: Path, expectedPathPackage: Path) -> None:
+    """Test that PackageSettings respects explicitly provided pathPackage."""
+    packageSettings = PackageSettings(pathPackage=explicitPathPackage)
+    assert packageSettings.pathPackage == expectedPathPackage, uniformTestFailureMessage(
+        expectedPathPackage, packageSettings.pathPackage, "PackageSettings explicit pathPackage", explicitPathPackage
+    )
+
+@pytest.mark.parametrize(
+    "fileExtension, expectedFileExtension",
+    [
+        (".fibonacci", ".fibonacci"),
+        (".prime", ".prime"),
+        (".txt", ".txt"),
+        (".md", ".md"),
+        (".json", ".json"),
+    ]
+)
+def testPackageSettingsWithCustomFileExtension(fileExtension: str, expectedFileExtension: str) -> None:
+    """Test that PackageSettings respects custom file extensions."""
+    packageSettings = PackageSettings(fileExtension=fileExtension)
+    assert packageSettings.fileExtension == expectedFileExtension, uniformTestFailureMessage(
+        expectedFileExtension, packageSettings.fileExtension, "PackageSettings custom fileExtension", fileExtension
+    )
+
+def testPackageSettingsDefaultValues() -> None:
+    """Test that PackageSettings has correct default values when no arguments provided."""
+    packageSettings = PackageSettings()
+
+    # Should have default file extension
+    assert packageSettings.fileExtension == '.py', uniformTestFailureMessage(
+        '.py', packageSettings.fileExtension, "PackageSettings default fileExtension"
+    )
+
+    # identifierPackage should be empty when no fallback provided
+    assert packageSettings.identifierPackage == '', uniformTestFailureMessage(
+        '', packageSettings.identifierPackage, "PackageSettings default identifierPackage"
+    )
+
+    # pathPackage should remain as Path() when identifierPackage is empty
+    expectedPath = Path()
+    assert packageSettings.pathPackage == expectedPath, uniformTestFailureMessage(
+        expectedPath, packageSettings.pathPackage, "PackageSettings default pathPackage"
+    )
+
+@pytest.mark.parametrize(
+    "identifierPackageFALLBACK, identifierPackage, pathPackage, fileExtension",
+    [
+        ("fallback", "custom", Path("C:/custom/path"), ".txt"),
+        ("fibonacci", "prime", Path("C:/fibonacci/lib"), ".md"),
+        ("defaultFallback", "overridePackage", Path("/usr/local/override"), ".json"),
+    ]
+)
+def testPackageSettingsAllParametersCombined(
+    identifierPackageFALLBACK: str,
+    identifierPackage: str,
+    pathPackage: Path,
+    fileExtension: str
+) -> None:
+    """Test PackageSettings with all parameters provided."""
+    packageSettings = PackageSettings(
+        identifierPackageFALLBACK,
+        identifierPackage=identifierPackage,
+        pathPackage=pathPackage,
+        fileExtension=fileExtension
+    )
+
+    assert packageSettings.identifierPackage == identifierPackage, uniformTestFailureMessage(
+        identifierPackage, packageSettings.identifierPackage, "PackageSettings combined identifierPackage"
+    )
+    assert packageSettings.pathPackage == pathPackage, uniformTestFailureMessage(
+        pathPackage, packageSettings.pathPackage, "PackageSettings combined pathPackage"
+    )
+    assert packageSettings.fileExtension == fileExtension, uniformTestFailureMessage(
+        fileExtension, packageSettings.fileExtension, "PackageSettings combined fileExtension"
+    )
+
+def testPackageSettingsFallbackIgnoredWhenExplicitIdentifierProvided() -> None:
+    """Test that fallback is ignored when explicit identifierPackage is provided."""
+    packageSettings = PackageSettings("shouldBeIgnored", identifierPackage="explicit")
+    assert packageSettings.identifierPackage == "explicit", uniformTestFailureMessage(
+        "explicit", packageSettings.identifierPackage, "PackageSettings fallback ignored"
+    )
+
+# Tests for helper functions
+@pytest.mark.parametrize(
+    "identifierPackageFALLBACK, expectedResult",
+    [
+        ("fibonacci", "hunterMakesPy"),  # Should read from pyproject.toml
+        ("prime", "hunterMakesPy"),  # Should read from pyproject.toml
+        ("nonExistentPackage", "hunterMakesPy"),  # Should read from pyproject.toml
+    ]
+)
+def testGetIdentifierPackagePACKAGING(identifierPackageFALLBACK: str, expectedResult: str) -> None:
+    """Test that getIdentifierPackagePACKAGING reads from pyproject.toml correctly."""
+    actual = getIdentifierPackagePACKAGING(identifierPackageFALLBACK)
+    assert actual == expectedResult, uniformTestFailureMessage(
+        expectedResult, actual, "getIdentifierPackagePACKAGING", identifierPackageFALLBACK
+    )
+
+@pytest.mark.parametrize(
+    "identifierPackage",
+    [
+        "hunterMakesPy",  # This package exists
+        "fibonacci",  # Non-existent package should fallback to cwd
+        "prime",  # Non-existent package should fallback to cwd
+    ]
+)
+def testGetPathPackageINSTALLING(identifierPackage: str) -> None:
+    """Test that getPathPackageINSTALLING returns valid Path objects."""
+    actual = getPathPackageINSTALLING(identifierPackage)
+    assert isinstance(actual, Path), uniformTestFailureMessage(
+        Path, type(actual), "getPathPackageINSTALLING type", identifierPackage
+    )
+    assert actual.exists() or actual == Path.cwd(), uniformTestFailureMessage(
+        "existing path or cwd", actual, "getPathPackageINSTALLING existence", identifierPackage
+    )

tests/test_filesystemToolkit.py

@@ -22,7 +22,7 @@ def testWriteStringToHereCreatesFileAndWritesContent(pathTmpTesting: pathlib.Pat
 	filePath = nestedDirectory / "test.txt"
 	writeStringToHere("hello world", filePath)
 	assert filePath.exists(), uniformTestFailureMessage(True, filePath.exists(), "testWriteStringToHereCreatesFileAndWritesContent", filePath)
-	assert filePath.read_text() == "hello world", uniformTestFailureMessage("hello world", filePath.read_text(), "testWriteStringToHereCreatesFileAndWritesContent", filePath)
+	assert filePath.read_text(encoding="utf-8") == "hello world", uniformTestFailureMessage("hello world", filePath.read_text(encoding="utf-8"), "testWriteStringToHereCreatesFileAndWritesContent", filePath)
 
 @pytest.mark.parametrize(
 	"moduleName, identifier, expectedType",

huntermakespy-0.1.0.dist-info/METADATA

@@ -1,38 +0,0 @@
-Metadata-Version: 2.4
-Name: hunterMakesPy
-Version: 0.1.0
-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/
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-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.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: charset_normalizer
-Requires-Dist: more_itertools
-Requires-Dist: numpy
-Requires-Dist: python_minifier
-Requires-Dist: tomli
-Provides-Extra: testing
-Requires-Dist: mypy; extra == "testing"
-Requires-Dist: pytest; extra == "testing"
-Requires-Dist: pytest-cov; extra == "testing"
-Requires-Dist: pytest-xdist; extra == "testing"
-Requires-Dist: pyupgrade; extra == "testing"
-Requires-Dist: setuptools-scm; extra == "testing"
-Dynamic: license-file

huntermakespy-0.1.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-hunterMakesPy/__init__.py,sha256=0zTe--KMtLeoBfsKGS5hH_vUEOuOXRQt1nA-K25bMBw,816
-hunterMakesPy/_theSSOT.py,sha256=HiZ_OqaiiHBDdbyKLJPk7aARQujShdX3dpYEpUbpWbM,1631
-hunterMakesPy/coping.py,sha256=AXa3KgAAO0L3KFNUoor8Tjuw7lDGQ2ZIsKUCDV4wR2Y,2529
-hunterMakesPy/dataStructures.py,sha256=2mJDAOxgSstV0gDNcpwA0mHruDbAfeRGIADWTCPXuHY,11397
-hunterMakesPy/filesystemToolkit.py,sha256=OdbMKPuOvverjptsToENU2HNGZ2XzAE7Bm6i0-yJfiU,4372
-hunterMakesPy/parseParameters.py,sha256=plrJ4xR1FQnQR9j-oeMAwB2H9r_8QD8OALnw0OH8Kt0,11947
-hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hunterMakesPy/pytestForYourUse.py,sha256=21BI8TXyinf8rMmS6dTsuRMBOOFTcyoG_gD__Gz_e7Q,13288
-hunterMakesPy/theTypes.py,sha256=C2d0uLn1VIx6_2CK41it3IP7iplSQqe51tzWc-RT320,306
-huntermakespy-0.1.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/conftest.py,sha256=MkNc4Ar6yYrnAok4t1NWsgyOYFDiGo1qwXHyp8ChJf4,1672
-tests/test_coping.py,sha256=c_rBHU0uoK2CKZhJSWtp7PPnHgdjNtdQEbWpc4P0VkE,2282
-tests/test_dataStructures.py,sha256=VhM3VzG1l8l3Iz1q9sQjpNBQTWSrl4zWbnefsGTccos,16406
-tests/test_filesystemToolkit.py,sha256=aMPyJ-EUCk4XvA08BSC5nDqKPY-YFBM_ePMGRZlSZOo,2413
-tests/test_parseParameters.py,sha256=bHD-O-OyWWwPOx3zvS53pSNPDm3LbFS05N5JcfNCLG4,1137
-huntermakespy-0.1.0.dist-info/METADATA,sha256=YPPLNpMrsIdnhqTuSNdIzEHB3-ckuMsmQEHy5hPSGyc,1474
-huntermakespy-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-huntermakespy-0.1.0.dist-info/top_level.txt,sha256=dUy7z3LNO6aqNjPD81tZjE5N9HO70a14Y9lAWjWC2gA,20
-huntermakespy-0.1.0.dist-info/RECORD,,