hunterMakesPy 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

hunterMakesPy/filesystemToolkit.py

@@ -1,6 +1,6 @@
 """File system and module import utilities.
 
-This module provides basic file I/O utilities such as importing callables from modules, and safely creating directories.
+This module provides basic file I/O utilities such as importing callables from modules, safely creating directories, and writing to files or streams (pipes).
 
 """
 
@@ -97,17 +97,25 @@ def makeDirsSafely(pathFilename: Any) -> None:
 		with contextlib.suppress(OSError):
 			Path(pathFilename).parent.mkdir(parents=True, exist_ok=True)
 
-def writeStringToHere(this: str, pathFilename: PathLike[Any] | PurePath) -> None:
-	"""Write a string to a file, creating parent directories as needed.
+def writeStringToHere(this: str, pathFilename: PathLike[Any] | PurePath | io.TextIOBase) -> None:
+	"""Write a string to a file or text stream.
+
+	This function writes a string to either a file path or an open text stream. For file paths, it creates parent directories as
+	needed and writes with UTF-8 encoding. For text streams, it writes directly to the stream and flushes the buffer.
 
 	Parameters
 	----------
 	this : str
-		The string content to write to the file.
-	pathFilename : PathLike[Any] | PurePath
-		The path and filename where the string will be written.
+		The string content to write.
+	pathFilename : PathLike[Any] | PurePath | io.TextIOBase
+		The target destination: either a file path or an open text stream.
 
 	"""
-	pathFilename = Path(pathFilename)
-	makeDirsSafely(pathFilename)
-	pathFilename.write_text(str(this), encoding='utf-8')
+	if isinstance(pathFilename, io.TextIOBase):
+		pathFilename.write(str(this))
+		pathFilename.flush()
+	else:
+		pathFilename = Path(pathFilename)
+		makeDirsSafely(pathFilename)
+		pathFilename.write_text(str(this), encoding='utf-8')
+

hunterMakesPy/tests/conftest.py

@@ -1,6 +1,7 @@
 # pyright: standard
 from collections.abc import Callable
 from typing import Any
+import io
 import pathlib
 import pytest
 
@@ -12,6 +13,36 @@ pathDataSamples = pathlib.Path("hunterMakesPy/tests/dataSamples")
 def pathTmpTesting(tmp_path: pathlib.Path) -> pathlib.Path:
 	return tmp_path
 
+# Fixture for predictable Python source code samples
+@pytest.fixture
+def dictionaryPythonSourceSamples() -> dict[str, str]:
+	"""Provide predictable Python source code samples for testing."""
+	return {
+		'functionFibonacci': "def fibonacciNumber():\n    return 13\n",
+		'functionPrime': "def primeNumber():\n    return 17\n",
+		'variablePrime': "prime = 19\n",
+		'variableFibonacci': "fibonacci = 21\n",
+		'classCardinal': "class CardinalDirection:\n    north = 'N'\n    south = 'S'\n",
+	}
+
+# Fixture for IO stream objects
+@pytest.fixture
+def streamMemoryString() -> io.StringIO:
+	"""Provide a StringIO object for testing stream operations."""
+	return io.StringIO()
+
+# Fixture for predictable directory names using cardinal directions
+@pytest.fixture
+def listDirectoryNamesCardinal() -> list[str]:
+	"""Provide predictable directory names using cardinal directions."""
+	return ['north', 'south', 'east', 'west']
+
+# Fixture for predictable file content using Fibonacci numbers
+@pytest.fixture
+def listFileContentsFibonacci() -> list[str]:
+	"""Provide predictable file contents using Fibonacci sequence."""
+	return ['fibonacci8', 'fibonacci13', 'fibonacci21', 'fibonacci34']
+
 def uniformTestFailureMessage(expected: Any, actual: Any, functionName: str, *arguments: Any, **keywordArguments: Any) -> str:
 	"""Format assertion message for any test comparison."""
 	listArgumentComponents: list[str] = [str(parameter) for parameter in arguments]

hunterMakesPy/tests/test_filesystemToolkit.py

@@ -1,46 +1,263 @@
 # pyright: standard
 from hunterMakesPy import importLogicalPath2Identifier, importPathFilename2Identifier, makeDirsSafely, writeStringToHere
-from hunterMakesPy.tests.conftest import uniformTestFailureMessage
+from hunterMakesPy.tests.conftest import standardizedEqualTo
 import io
 import math
 import os
 import pathlib
 import pytest
+import sys
+
+@pytest.mark.parametrize(
+	"logicalPathModuleTarget, identifierTarget, packageIdentifierIfRelativeTarget, expectedType",
+	[
+		('math', 'gcd', None, type(math.gcd)),
+		('os.path', 'join', None, type(os.path.join)),
+		('pathlib', 'Path', None, type(pathlib.Path)),
+		('sys', 'version', None, type(sys.version)),
+	]
+)
+def testImportLogicalPath2IdentifierWithAbsolutePaths(
+	logicalPathModuleTarget: str,
+	identifierTarget: str,
+	packageIdentifierIfRelativeTarget: str | None,
+	expectedType: type
+) -> None:
+	"""Test importing identifiers from modules using absolute logical paths."""
+	identifierImported = importLogicalPath2Identifier(logicalPathModuleTarget, identifierTarget, packageIdentifierIfRelativeTarget)
+
+	assert isinstance(identifierImported, expectedType), (
+		f"\nTesting: `importLogicalPath2Identifier({logicalPathModuleTarget}, {identifierTarget}, {packageIdentifierIfRelativeTarget})`\n"
+		f"Expected type: {expectedType}\n"
+		f"Got type: {type(identifierImported)}"
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, identifierTarget, moduleIdentifierTarget, expectedValueWhenCalled",
+	[
+		("def fibonacciNumber():\n    return 13\n", "fibonacciNumber", None, 13),
+		("def primeNumber():\n    return 17\n", "primeNumber", "moduleNorth", 17),
+		("def cardinalDirection():\n    return 'N'\n", "cardinalDirection", "moduleSouth", 'N'),
+		("def fibonacciSequence():\n    return 21\n", "fibonacciSequence", "moduleEast", 21),
+	]
+)
+def testImportPathFilename2IdentifierWithCallables(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	identifierTarget: str,
+	moduleIdentifierTarget: str | None,
+	expectedValueWhenCalled: object
+) -> None:
+	"""Test importing callable identifiers from Python files."""
+	pathFilenameModule = pathTmpTesting / f"moduleTest{hash(pythonSourceTarget) % 89}.py"  # Use prime number 89
+	pathFilenameModule.write_text(pythonSourceTarget)
+
+	standardizedEqualTo(
+		expectedValueWhenCalled,
+		lambda: importPathFilename2Identifier(pathFilenameModule, identifierTarget, moduleIdentifierTarget)(),
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, identifierTarget, moduleIdentifierTarget, expectedValue",
+	[
+		("prime = 23\n", "prime", None, 23),
+		("fibonacci = 34\n", "fibonacci", "moduleWest", 34),
+		("cardinalDirection = 'S'\n", "cardinalDirection", "moduleNorthEast", 'S'),
+		("sequenceValue = 55\n", "sequenceValue", "moduleSouthWest", 55),
+	]
+)
+def testImportPathFilename2IdentifierWithVariables(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	identifierTarget: str,
+	moduleIdentifierTarget: str | None,
+	expectedValue: object
+) -> None:
+	"""Test importing variable identifiers from Python files."""
+	pathFilenameModule = pathTmpTesting / f"moduleTest{hash(pythonSourceTarget) % 97}.py"  # Use prime number 97
+	pathFilenameModule.write_text(pythonSourceTarget)
+
+	standardizedEqualTo(
+		expectedValue,
+		importPathFilename2Identifier,
+		pathFilenameModule,
+		identifierTarget,
+		moduleIdentifierTarget
+	)
+
+
+@pytest.mark.parametrize(
+	"listDirectoryComponents, filenameTarget",
+	[
+		(['north', 'south'], 'fibonacci13.txt'),
+		(['east', 'west', 'northeast'], 'prime17.txt'),
+		(['southwest', 'northwest'], 'fibonacci21.txt'),
+		(['cardinal', 'directions', 'multiple'], 'prime23.txt'),
+	]
+)
+def testMakeDirsSafelyCreatesNestedDirectories(
+	pathTmpTesting: pathlib.Path,
+	listDirectoryComponents: list[str],
+	filenameTarget: str
+) -> None:
+	"""Test that makeDirsSafely creates nested parent directories."""
+	pathDirectoryNested = pathTmpTesting
+	for directoryComponent in listDirectoryComponents:
+		pathDirectoryNested = pathDirectoryNested / directoryComponent
+
+	pathFilenameTarget = pathDirectoryNested / filenameTarget
+	makeDirsSafely(pathFilenameTarget)
+
+	assert pathDirectoryNested.exists() and pathDirectoryNested.is_dir(), (
+		f"\nTesting: `makeDirsSafely({pathFilenameTarget})`\n"
+		f"Expected: Directory {pathDirectoryNested} to exist and be a directory\n"
+		f"Got: exists={pathDirectoryNested.exists()}, is_dir={pathDirectoryNested.is_dir() if pathDirectoryNested.exists() else False}"
+	)
+
+
+@pytest.mark.parametrize(
+	"streamTypeTarget",
+	[
+		io.StringIO(),
+		io.StringIO("initialContent"),
+	]
+)
+def testMakeDirsSafelyWithIOStreamDoesNotRaise(streamTypeTarget: io.IOBase) -> None:
+	"""Test that makeDirsSafely handles IO streams without raising exceptions."""
+	# This test verifies that no exception is raised
+	makeDirsSafely(streamTypeTarget)
+
+	# If we reach this point, no exception was raised
+	assert True
+
+
+@pytest.mark.parametrize(
+	"listDirectoryComponents, filenameTarget, contentTarget",
+	[
+		(['north', 'fibonacci'], 'test13.txt', 'fibonacci content 13'),
+		(['south', 'prime'], 'test17.txt', 'prime content 17'),
+		(['east', 'cardinal'], 'test21.txt', 'cardinal direction east'),
+		(['west', 'sequence'], 'test23.txt', 'sequence value 23'),
+	]
+)
+def testWriteStringToHereCreatesFileAndDirectories(
+	pathTmpTesting: pathlib.Path,
+	listDirectoryComponents: list[str],
+	filenameTarget: str,
+	contentTarget: str
+) -> None:
+	"""Test that writeStringToHere creates directories and writes content to files."""
+	pathDirectoryNested = pathTmpTesting
+	for directoryComponent in listDirectoryComponents:
+		pathDirectoryNested = pathDirectoryNested / directoryComponent
+
+	pathFilenameTarget = pathDirectoryNested / filenameTarget
+	writeStringToHere(contentTarget, pathFilenameTarget)
+
+	assert pathFilenameTarget.exists(), (
+		f"\nTesting: `writeStringToHere({contentTarget}, {pathFilenameTarget})`\n"
+		f"Expected: File {pathFilenameTarget} to exist\n"
+		f"Got: exists={pathFilenameTarget.exists()}"
+	)
+
+	contentActual = pathFilenameTarget.read_text(encoding="utf-8")
+	assert contentActual == contentTarget, (
+		f"\nTesting: `writeStringToHere({contentTarget}, {pathFilenameTarget})`\n"
+		f"Expected content: {contentTarget}\n"
+		f"Got content: {contentActual}"
+	)
+
+
+@pytest.mark.parametrize(
+	"contentTarget",
+	[
+		'fibonacci content 34',
+		'prime content 29',
+		'cardinal direction NE',
+		'sequence value 55',
+	]
+)
+def testWriteStringToHereWithIOStream(contentTarget: str) -> None:
+	"""Test that writeStringToHere writes content to IO streams."""
+	streamMemory = io.StringIO()
+	writeStringToHere(contentTarget, streamMemory)
+
+	contentActual = streamMemory.getvalue()
+	assert contentActual == contentTarget, (
+		f"\nTesting: `writeStringToHere({contentTarget}, StringIO)`\n"
+		f"Expected content: {contentTarget}\n"
+		f"Got content: {contentActual}"
+	)
+
+
+@pytest.mark.parametrize(
+	"logicalPathModuleTarget, identifierTarget, expectedExceptionType",
+	[
+		('nonexistent.module', 'anyIdentifier', ModuleNotFoundError),
+		('math', 'nonexistentFunction', AttributeError),
+		('os.path', 'nonexistentAttribute', AttributeError),
+	]
+)
+def testImportLogicalPath2IdentifierWithInvalidInputs(
+	logicalPathModuleTarget: str,
+	identifierTarget: str,
+	expectedExceptionType: type[Exception]
+) -> None:
+	"""Test that importLogicalPath2Identifier raises appropriate exceptions for invalid inputs."""
+	standardizedEqualTo(
+		expectedExceptionType,
+		importLogicalPath2Identifier,
+		logicalPathModuleTarget,
+		identifierTarget
+	)
+
+
+@pytest.mark.parametrize(
+	"pathFilenameTarget, identifierTarget, expectedExceptionType",
+	[
+		('nonexistent.py', 'anyIdentifier', FileNotFoundError),
+	]
+)
+def testImportPathFilename2IdentifierWithInvalidInputs(
+	pathTmpTesting: pathlib.Path,
+	pathFilenameTarget: str,
+	identifierTarget: str,
+	expectedExceptionType: type[Exception]
+) -> None:
+	"""Test that importPathFilename2Identifier raises appropriate exceptions for invalid inputs."""
+	pathFilenameNonexistent = pathTmpTesting / pathFilenameTarget
+
+	standardizedEqualTo(
+		expectedExceptionType,
+		importPathFilename2Identifier,
+		pathFilenameNonexistent,
+		identifierTarget
+	)
+
+
+@pytest.mark.parametrize(
+	"pythonSourceTarget, identifierTarget, expectedExceptionType",
+	[
+		("def validFunction():\n    return 89\n", "nonexistentIdentifier", AttributeError),
+		("validVariable = 97\n", "nonexistentVariable", AttributeError),
+	]
+)
+def testImportPathFilename2IdentifierWithValidFileInvalidIdentifier(
+	pathTmpTesting: pathlib.Path,
+	pythonSourceTarget: str,
+	identifierTarget: str,
+	expectedExceptionType: type[Exception]
+) -> None:
+	"""Test that importPathFilename2Identifier raises AttributeError for nonexistent identifiers in valid files."""
+	pathFilenameModule = pathTmpTesting / f"moduleTest{hash(pythonSourceTarget) % 101}.py"  # Use prime number 101
+	pathFilenameModule.write_text(pythonSourceTarget)
+
+	standardizedEqualTo(
+		expectedExceptionType,
+		importPathFilename2Identifier,
+		pathFilenameModule,
+		identifierTarget
+	)
 
-def testMakeDirsSafelyCreatesParentDirectories(pathTmpTesting: pathlib.Path) -> None:
-	nestedDirectory = pathTmpTesting / "sub1" / "sub2"
-	filePath = nestedDirectory / "dummy.txt"
-	makeDirsSafely(filePath)
-	assert nestedDirectory.exists() and nestedDirectory.is_dir(), uniformTestFailureMessage(True, nestedDirectory.exists() and nestedDirectory.is_dir(), "testMakeDirsSafelyCreatesParentDirectories", filePath)
-
-def testMakeDirsSafelyWithIOBaseDoesNotRaise() -> None:
-	memoryStream = io.StringIO()
-	makeDirsSafely(memoryStream)
-
-def testWriteStringToHereCreatesFileAndWritesContent(pathTmpTesting: pathlib.Path) -> None:
-	nestedDirectory = pathTmpTesting / "a" / "b"
-	filePath = nestedDirectory / "test.txt"
-	writeStringToHere("hello world", filePath)
-	assert filePath.exists(), uniformTestFailureMessage(True, filePath.exists(), "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",
-	[("math", "gcd", type(math.gcd)),("os.path", "join", type(os.path.join))])
-def testImportLogicalPath2Identifier(moduleName: str, identifier: str, expectedType: type) -> None:
-	imported = importLogicalPath2Identifier(moduleName, identifier)
-	assert isinstance(imported, expectedType), uniformTestFailureMessage(expectedType, type(imported), "testImportLogicalPath2Identifier", (moduleName, identifier))
-
-@pytest.mark.parametrize(
-	"source, identifier, expected"
-	, [("def fibonacciNumber():\n    return 13\n", "fibonacciNumber", 13)
-	, ("prime = 17\n", "prime", 17)])
-def testImportPathFilename2Identifier(tmp_path: pathlib.Path, source: str, identifier: str, expected: object) -> None:
-	filePath = tmp_path / "moduleTest.py"
-	filePath.write_text(source)
-	imported = importPathFilename2Identifier(filePath, identifier)
-	if callable(imported):
-		actual = imported()
-	else:
-		actual = imported
-	assert actual == expected, uniformTestFailureMessage(expected, actual, "testImportPathFilename2Identifier", (filePath, identifier))

{huntermakespy-0.2.0.dist-info → huntermakespy-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hunterMakesPy
-Version: 0.2.0
+Version: 0.2.1
 Summary: Easy Python functions making making functional Python functions easier.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -74,7 +74,7 @@ def findConfiguration(configName: str) -> dict[str, str] | None:
 
 config = raiseIfNone(
     findConfiguration("database"),
-    "Configuration 'database' is required but not found"
+    "I could not find Configuration 'database', but I need it to continue."
 )
 ```
 
@@ -83,19 +83,19 @@ config = raiseIfNone(
 Parameter validation, integer parsing, and concurrency handling.
 
 ```python
-from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
+import hunterMakesPy as humpy
 
 # 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
+cpuLimit = humpy.defineConcurrencyLimit(limit=0.75)  # Use 75% of available CPUs
+cpuLimit = humpy.defineConcurrencyLimit(limit=True)  # Use exactly 1 CPU
+cpuLimit = humpy.defineConcurrencyLimit(limit=4)     # Use exactly 4 CPUs
 
 # Robust integer validation
-validatedIntegers = intInnit([1, "2", 3.0, "4"], "port_numbers")
+validatedIntegers = humpy.intInnit([1, "2", 3.0, "4"], "port_numbers")
 
 # String-to-boolean conversion for configuration
 userInput = "True"
-booleanValue = oopsieKwargsie(userInput)  # Returns True
+booleanValue = humpy.oopsieKwargsie(userInput)  # Returns True
 ```
 
 ## File System Utilities
@@ -103,20 +103,15 @@ booleanValue = oopsieKwargsie(userInput)  # Returns True
 Safe file operations and dynamic module importing.
 
 ```python
-from hunterMakesPy import (
-    importLogicalPath2Identifier,
-    importPathFilename2Identifier,
-    makeDirsSafely,
-    writeStringToHere
-)
+import hunterMakesPy as humpy
 
 # Dynamic imports
-gcdFunction = importLogicalPath2Identifier("math", "gcd")
-customFunction = importPathFilename2Identifier("path/to/module.py", "functionName")
+gcdFunction = humpy.importLogicalPath2Identifier("math", "gcd")
+customFunction = humpy.importPathFilename2Identifier("path/to/module.py", "functionName")
 
 # Safe file operations
 pathFilename = Path("deep/nested/directory/file.txt")
-writeStringToHere("content", pathFilename)  # Creates directories automatically
+humpy.writeStringToHere("content", pathFilename)  # Creates directories automatically
 ```
 
 ## Data Structure Manipulation
@@ -124,21 +119,21 @@ writeStringToHere("content", pathFilename)  # Creates directories automatically
 Utilities for string extraction, data flattening, and array compression.
 
 ```python
-from hunterMakesPy import stringItUp, updateExtendPolishDictionaryLists, autoDecodingRLE
+import hunterMakesPy as humpy
 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']
+allStrings = humpy.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)
+dictionaryAlpha = {"servers": ["chicago", "tokyo"], "databases": ["elm"]}
+dictionaryBeta = {"servers": ["mumbai"], "databases": ["oak", "cedar"]}
+merged = humpy.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)]"
+compressed = humpy.autoDecodingRLE(arrayData)  # "[1,*range(2,6)]+[5]*2+[*range(6,10)]"
 ```
 
 ## Testing
@@ -146,7 +141,7 @@ compressed = autoDecodingRLE(arrayData)  # "[1,*range(2,6)]+[5]*2+[*range(6,10)]
 The package includes comprehensive test suites that you can import and run:
 
 ```python
-from hunterMakesPy.pytestForYourUse import (
+from hunterMakesPy.tests.test_parseParameters import (
     PytestFor_defineConcurrencyLimit,
     PytestFor_intInnit,
     PytestFor_oopsieKwargsie
@@ -158,8 +153,9 @@ for nameOfTest, callablePytest in listOfTests:
     callablePytest()
 
 # Or test your own compatible functions
-@pytest.mark.parametrize("nameOfTest,callablePytest",
-                        PytestFor_intInnit(callableToTest=myFunction))
+@pytest.mark.parametrize(
+  "nameOfTest,callablePytest"
+  , PytestFor_intInnit(callableToTest=myFunction))
 def test_myFunction(nameOfTest, callablePytest):
     callablePytest()
 ```

{huntermakespy-0.2.0.dist-info → huntermakespy-0.2.1.dist-info}/RECORD

@@ -2,19 +2,19 @@ hunterMakesPy/__init__.py,sha256=bVF1F2Mdo5AOiioEfxKvNrnsa3vCFI16eMK7Oy5O5TU,145
 hunterMakesPy/_theSSOT.py,sha256=lkLOG3oTIWNKD_ULX55chlUGNqCHgqVIrBvolvK1vbQ,153
 hunterMakesPy/coping.py,sha256=covqNFAwkF9gjafrlAvMdtCO8haFsESQBhO-7s68qSg,5581
 hunterMakesPy/dataStructures.py,sha256=CFyGjmAOoN2MoEPwWwWdwKNXmOXX8kCS3ttMOa2Rsx0,11379
-hunterMakesPy/filesystemToolkit.py,sha256=vDYS0Rc1aP7ETLXHKoO3TfOpuwJQFQW2ybwtJNiIIo4,4305
+hunterMakesPy/filesystemToolkit.py,sha256=jd7H5UtrIrPiCYWcvNBNa6DAy-2Ewcf21-jbGXg_IVI,4702
 hunterMakesPy/parseParameters.py,sha256=DXpyATx7trGBg_8jlO5dXGfLcG8vg_lU3R1sq1rRFOQ,11644
 hunterMakesPy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hunterMakesPy/pytestForYourUse.py,sha256=GiN1C1gTTM0ZunRPEMnrKlLQLMdH0wF_ZGr_RPgRjjA,500
 hunterMakesPy/theTypes.py,sha256=C2d0uLn1VIx6_2CK41it3IP7iplSQqe51tzWc-RT320,306
 hunterMakesPy/tests/__init__.py,sha256=C_FzfKDi_VrGVxlenWHyOYtKShAKlt3KW14jeRx1mQI,224
-hunterMakesPy/tests/conftest.py,sha256=K-XAGvYp6CZVCox5G5DvFA9Qk7X-oBl1BccmOXVn0BI,1645
+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=HmRKHXAvGz12YAI-FT9tz42CDNK6p5NcZEVPLzdfetE,2460
+hunterMakesPy/tests/test_filesystemToolkit.py,sha256=q2voXjCbQPIT8l8VF9iuWX1Bs2ZieABItWoVkITj_fo,8841
 hunterMakesPy/tests/test_parseParameters.py,sha256=80npsoWcCackjxvoW2dMXMpHeale7fuRXyXp78MibLs,14037
-huntermakespy-0.2.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-huntermakespy-0.2.0.dist-info/METADATA,sha256=FnWnf_rjZ_-uC3s1j4rUeLmOYc4B1s6j8TOJJcn3QlY,6631
-huntermakespy-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-huntermakespy-0.2.0.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
-huntermakespy-0.2.0.dist-info/RECORD,,
+huntermakespy-0.2.1.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+huntermakespy-0.2.1.dist-info/METADATA,sha256=U7mdPv2TiV-JgdBigReM9zxA1N9uZ0Nb93fmASS1-bk,6501
+huntermakespy-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+huntermakespy-0.2.1.dist-info/top_level.txt,sha256=Uh4bj8EDTdsRpqY1VlK_his_B4HDfZ6Tqrwhoj75P_w,14
+huntermakespy-0.2.1.dist-info/RECORD,,