Z0Z-tools 0.5.2__py3-none-any.whl

Z0Z_tools/Z0Z_dataStructure.py

@@ -0,0 +1,85 @@
+from typing import Any, Dict, List
+
+def stringItUp(*scrapPile: Any) -> List[str]:
+    """
+    Recursively extracts all elements from nested data structures and converts the elements to strings.
+    Order is not preserved.
+    Parameters:
+        *scrapPile: One or more data structures to unpack and convert to strings.
+    Returns:
+        listStrungUp: A list of string versions of all elements in the input data structure.
+    """
+    listStrungUp = []
+
+    def drill(KitKat: Any) -> None:
+        if isinstance(KitKat, str):
+            listStrungUp.append(KitKat)
+        elif isinstance(KitKat, (bool, bytearray, bytes, complex, float, int, memoryview, type(None))):
+            listStrungUp.append(str(KitKat))
+        elif isinstance(KitKat, dict):
+            for broken, piece in KitKat.items():
+                drill(broken)
+                drill(piece)
+        elif isinstance(KitKat, (frozenset, list, range, set, tuple)):
+            for kit in KitKat:
+                drill(kit)
+        elif 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
+    try:
+        for scrap in scrapPile:
+            drill(scrap)
+    except RecursionError:
+        listStrungUp.append(repr(scrap))
+    return listStrungUp
+
+def updateExtendPolishDictionaryLists(*dictionaryLists: Dict[str, List[Any]], destroyDuplicates: bool = False, reorderLists: bool = False, \
+    killErroneousDataTypes: bool = False) -> Dict[str, List[Any]]:
+    """
+    Merges multiple dictionaries containing lists into a single dictionary, with options to handle duplicates, 
+    list ordering, and erroneous data types.
+    Parameters:
+        *dictionaryLists: Variable number of dictionaries to be merged. If only one dictionary is passed, it will be processed based on the provided options.
+        destroyDuplicates (False): If True, removes duplicate elements from the lists. Defaults to False.
+        ignoreListOrdering (False): If True, sorts the lists. Defaults to False.
+        killErroneousDataTypes (False): If True, skips lists that cause a TypeError during merging. Defaults to False.
+    Returns:
+        ePluribusUnum: A single dictionary with merged lists based on the provided options. If only one dictionary is passed, 
+        it will be cleaned up based on the options.
+    Note:
+        The returned value, `ePluribusUnum`, is a so-called primitive dictionary (`typing.Dict`). Furthermore, every dictionary key is a 
+        so-called primitive string (cf. `str()`) and every dictionary value is a so-called primitive list (`typing.List`). If `dictionaryLists` 
+        has other data types, the data types will not be preserved. That could have unexpected consequences: in some cases, for example, conversion 
+        from the original data type to a `typing.List` will not preserve the order even if you want the order 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

Z0Z_tools/Z0Z_io.py

@@ -0,0 +1,23 @@
+from typing import Iterable, Any, Union
+import os
+
+def dataTabularTOpathFilenameDelimited(pathFilename: Union[str, os.PathLike[Any]], tableRows: Iterable[Iterable[Any]], \
+    tableColumns: Iterable[Any], delimiterOutput: str = '\t') -> None:
+    """
+    Writes tabular data to a delimited file. This is a low-quality function: you'd probably be better off with something else.
+    Parameters:
+        pathFilename: The path and filename where the data will be written.
+        tableRows: The rows of the table, where each row is a list of strings or floats.
+        tableColumns: The column headers for the table.
+        delimiterOutput (tab): The delimiter to use in the output file. Defaults to *tab*.
+    Returns:
+        None:
+
+    This function still exists because I have not refactored `analyzeAudio.analyzeAudioListPathFilenames()`. The structure of
+    that function's returned data is easily handled by this function. See https://github.com/hunterhogan/analyzeAudio
+    """
+    with open(pathFilename, 'w', newline='') as writeStream:
+        writeStream.write(delimiterOutput.join(tableColumns) + '\n')
+        
+        for row in tableRows:
+            writeStream.write(delimiterOutput.join(map(str, row)) + '\n')

Z0Z_tools/Z0Z_ioAudio.py

@@ -0,0 +1,123 @@
+from numpy.typing import NDArray
+from typing import Any, BinaryIO, Dict, List, Sequence, Tuple, Union
+import io
+import numpy
+import os
+import pathlib
+import samplerate
+import soundfile
+
+def loadWaveforms(listPathFilenames: Union[Sequence[str], Sequence[os.PathLike[str]]], sampleRate: int = 44100) -> NDArray[numpy.float32]:
+    """
+    Load a list of audio files into a single array.
+    Parameters:
+        listPathFilenames: List of file paths to the audio files.
+        sampleRate (44100): Target sample rate for the waveforms; the function will resample if necessary. Defaults to 44100.
+    Returns:
+        arrayWaveforms: A single NumPy array of shape (COUNTchannels, COUNTsamplesMaximum, COUNTwaveforms)
+    """
+    axisOrderMapping: Dict[str, int] = {'indexingAxis': -1, 'axisTime': -2, 'axisChannels': 0}
+    axesSizes: Dict[str, int] = {keyName: 1 for keyName in axisOrderMapping.keys()}
+    COUNTaxes: int = len(axisOrderMapping)
+    listShapeIndexToSize: List[int] = [9001] * COUNTaxes
+
+    COUNTwaveforms: int = len(listPathFilenames)
+    axesSizes['indexingAxis'] = COUNTwaveforms
+    COUNTchannels: int = 2
+    axesSizes['axisChannels'] = COUNTchannels
+
+    listCOUNTsamples: List[int] = []
+    axisTime: int = 0
+    
+    for pathFilename in listPathFilenames:
+        with soundfile.SoundFile(pathFilename) as readSoundFile:
+            sampleRateSoundFile: int = readSoundFile.samplerate
+            waveform: NDArray[numpy.float32] = readSoundFile.read(dtype='float32', always_2d=True).astype(numpy.float32)
+            if sampleRateSoundFile != sampleRate:
+                waveform = resampleWaveform(waveform, sampleRate, sampleRateSoundFile)
+            listCOUNTsamples.append(waveform.shape[axisTime])
+            
+    COUNTsamplesMaximum: int = max(listCOUNTsamples)
+    axesSizes['axisTime'] = COUNTsamplesMaximum
+
+    for keyName, axisSize in axesSizes.items():
+        axisNormalized: int = (axisOrderMapping[keyName] + COUNTaxes) % COUNTaxes
+        listShapeIndexToSize[axisNormalized] = axisSize
+    tupleShapeArray: Tuple[int, ...] = tuple(listShapeIndexToSize)
+
+    # `numpy.zeros` so that shorter waveforms are safely padded with zeros
+    arrayWaveforms: NDArray[numpy.float32] = numpy.zeros(tupleShapeArray, dtype=numpy.float32)
+
+    for index in range(COUNTwaveforms):
+        with soundfile.SoundFile(listPathFilenames[index]) as readSoundFile:
+            sampleRateSoundFile: int = readSoundFile.samplerate
+            waveform: NDArray[numpy.float32] = readSoundFile.read(dtype='float32', always_2d=True).astype(numpy.float32)
+
+            if sampleRateSoundFile != sampleRate:
+                waveform = resampleWaveform(waveform, sampleRate, sampleRateSoundFile)
+
+            COUNTsamples: int = waveform.shape[axisTime]
+            arrayWaveforms[:, 0:COUNTsamples, index] = waveform.T
+
+    return arrayWaveforms
+
+def readAudioFile(pathFilename: Union[str, os.PathLike[Any], BinaryIO], sampleRate: int = 44100) -> NDArray[numpy.float32]:
+    """
+    Reads an audio file and returns its data as a NumPy array. Mono is always converted to stereo.
+
+    Parameters:
+        pathFilename: The path to the audio file.
+        sampleRate (44100): The sample rate to use when reading the file. Defaults to 44100.
+
+    Returns:
+        waveform: The audio data in an array shaped (channels, samples).
+    """
+    with soundfile.SoundFile(pathFilename) as readStream:
+        sampleRateSource: int = readStream.samplerate
+        waveform: NDArray[numpy.float32] = readStream.read(dtype='float32', always_2d=True).astype(numpy.float32)
+        waveform = resampleWaveform(waveform, sampleRateDesired=sampleRate, sampleRateSource=sampleRateSource)
+        return waveform.T
+
+def resampleWaveform(waveform: NDArray[numpy.float32], sampleRateDesired: int, sampleRateSource: int) -> NDArray[numpy.float32]:
+    """
+    Resamples the waveform to the desired sample rate.
+
+    Parameters:
+        waveform: The input audio data.
+        sampleRateDesired: The desired sample rate.
+        sampleRateSource: The original sample rate of the waveform.
+
+    Returns:
+        waveformResampled: The resampled waveform.
+    """
+    if sampleRateSource != sampleRateDesired:
+        converter: str = 'sinc_best'
+        ratio: float = sampleRateDesired / sampleRateSource
+        waveformResampled: NDArray[numpy.float32] = samplerate.resample(waveform, ratio, converter)
+        return waveformResampled
+    else:
+        return waveform
+
+def writeWav(pathFilename: Union[str, os.PathLike[Any], io.IOBase], waveform: NDArray[Any], sampleRate: int = 44100) -> None:
+    """
+    Writes a waveform to a WAV file.
+
+    Parameters:
+        pathFilename: The path and filename where the WAV file will be saved.
+        waveform: The waveform data to be written to the WAV file. The waveform should be in the shape (channels, samples).
+        sampleRate (44100): The sample rate of the waveform. Defaults to 44100 Hz.
+
+    Notes:
+        The function will create any necessary directories if they do not exist.
+        The function will overwrite the file if it already exists without prompting or informing the user.
+
+    Returns:
+        None:
+
+    """
+    if not isinstance(pathFilename, io.IOBase):
+        try:
+            pathlib.Path(pathFilename).parent.mkdir(parents=True, exist_ok=True)
+        except OSError:
+            pass
+    soundfile.write(file=pathFilename, data=waveform.T, samplerate=sampleRate, subtype='FLOAT', format='WAV')

Z0Z_tools/__init__.py

@@ -0,0 +1,19 @@
+__author__ = "Hunter Hogan"
+__version__ = "0.5.2"
+
+from Z0Z_tools.pipAnything import installPackageTarget, makeListRequirementsFromRequirementsFile
+from Z0Z_tools.Z0Z_dataStructure import stringItUp, updateExtendPolishDictionaryLists
+from Z0Z_tools.Z0Z_io import dataTabularTOpathFilenameDelimited
+from Z0Z_tools.Z0Z_ioAudio import writeWav, readAudioFile, loadWaveforms
+
+__all__ = [
+    'dataTabularTOpathFilenameDelimited',
+    'installPackageTarget',
+    'loadWaveforms',
+    'makeListRequirementsFromRequirementsFile',
+    'readAudioFile',
+    'stringItUp',
+    'updateExtendPolishDictionaryLists',
+    'writeWav',
+]
+

Z0Z_tools/pipAnything.py

@@ -0,0 +1,156 @@
+"""
+Functions:
+    - installPackageTarget: Tries to trick pip into installing the package from a given directory.
+    - makeListRequirementsFromRequirementsFile: Reads a requirements.txt file, discards anything it couldn't understand, and creates a list of packages. 
+
+Usage:
+    from pipAnything import installPackageTarget
+    installPackageTarget('path/to/packageTarget')
+
+    pip will attempt to install requirements.txt, but don't rely on dependencies being installed.
+"""
+
+from packaging.requirements import Requirement
+from typing import List, Union
+import os
+import pathlib
+import subprocess
+import sys
+import tempfile
+
+def makeListRequirementsFromRequirementsFile(*pathFilenames: Union[str, os.PathLike[str]]) -> List[str]:
+    """
+    Reads one or more requirements files and extracts valid package requirements.
+    Parameters:
+        *pathFilenames: One or more paths to requirements files.
+    Returns:
+        listRequirements: A list of unique, valid package requirements found in the provided files.
+    The function performs the following steps:
+    1. Iterates over each provided file path.
+    2. Checks if the file exists.
+    3. Reads the file line by line, removing comments and trimming whitespace.
+    4. Skips lines that are empty or contain spaces/tabs after sanitization.
+    5. Validates if the sanitized line is a valid requirement.
+    6. Collects valid requirements and removes duplicates before returning the list.
+    """
+    listRequirements = []
+    
+    for pathFilename in pathFilenames:
+        if pathlib.Path(pathFilename).exists():
+            try:
+                filesystemObjectRead = open(pathFilename, 'r')
+                for commentedLine in filesystemObjectRead:
+                    sanitizedLine = commentedLine.split('#')[0].strip()  # Remove comments and trim whitespace
+
+                    # Skip lines that are empty or contain spaces/tabs after sanitization
+                    if "\t" in sanitizedLine or " " in sanitizedLine or not sanitizedLine:
+                        continue
+
+                    # Validate if it's a valid requirement
+                    try:
+                        Requirement(sanitizedLine)
+                        listRequirements.append(sanitizedLine)
+                    except:
+                        pass  # Skip invalid requirement lines
+            finally:
+                filesystemObjectRead.close()
+
+    return sorted(set(listRequirements))  # Remove duplicates
+
+def make_setupDOTpy(relativePathPackage: Union[str, os.PathLike[str]], listRequirements: List[str]) -> str:
+    """
+    Generates setup.py file content for installing the package.
+
+    Parameters:
+        relativePathPackage: The relative path to the package directory.
+        listRequirements: A list of requirements to be included in install_requires.
+
+    Returns:
+        str: The setup.py content to be written to a file.
+    """
+    return rf"""
+import os
+from setuptools import setup, find_packages
+
+setup(
+    name='{pathlib.Path(relativePathPackage).name}',
+    version='0.0.0',
+    packages=find_packages(where=r'{relativePathPackage}'),
+    package_dir={{'': r'{relativePathPackage}'}},
+    install_requires={listRequirements},
+    include_package_data=True,
+)
+""" 
+
+def installPackageTarget(pathPackageTarget: Union[str, os.PathLike[str]]) -> None:
+    """
+    Installs a package by creating a temporary setup.py and tricking pip into installing it.
+
+    Parameters:
+        pathPackageTarget: The directory path of the package to be installed.
+    """
+    filenameRequirementsHARDCODED = pathlib.Path('requirements.txt')
+    filenameRequirements = pathlib.Path(filenameRequirementsHARDCODED)
+
+    pathPackage = pathlib.Path(pathPackageTarget).resolve()
+    pathSystemTemporary = pathlib.Path(tempfile.mkdtemp())
+    pathFilename_setupDOTpy = pathSystemTemporary / 'setup.py'
+
+    pathFilenameRequirements = pathPackage / filenameRequirements
+    listRequirements = makeListRequirementsFromRequirementsFile(pathFilenameRequirements)
+
+    # Try-finally block for file handling: with-as doesn't always work
+    writeStream = None
+    try:
+        writeStream = pathFilename_setupDOTpy.open(mode='w')
+        relativePathPackage = pathPackage.relative_to(pathSystemTemporary, walk_up=True).as_posix()
+        writeStream.write(make_setupDOTpy(relativePathPackage, listRequirements))
+    finally:
+        if writeStream:
+            writeStream.close()
+
+    # Run pip to install the package from the temporary directory
+    subprocessPython = subprocess.Popen(
+    # `pip` needs a RELATIVE PATH, not an absolute path, and not a path+filename. 
+        args=[sys.executable, '-m', 'pip', 'install', str(pathSystemTemporary)],
+        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+    )
+
+    # Output the subprocess stdout in real-time
+    if subprocessPython.stdout:
+        for lineStdout in subprocessPython.stdout:
+            print(lineStdout, end="")
+
+    subprocessPython.wait()
+
+    # Clean up by removing setup.py
+    pathFilename_setupDOTpy.unlink()
+
+def everyone_knows_what___main___is() -> None:
+    """A rudimentary CLI for the module.
+    call `installPackageTarget` from other modules."""
+    packageTarget = sys.argv[1] if len(sys.argv) > 1 else ''
+    pathPackageTarget = pathlib.Path(packageTarget)
+    if not pathPackageTarget.is_dir() or len(sys.argv) != 2:
+        namespaceModule = pathlib.Path(__file__).stem
+        namespacePackage = pathlib.Path(__file__).parent.stem
+        print(f"\n{namespaceModule} says, 'That didn't work. Try again?'\n\n"
+              f"Usage:\tpython -m {namespacePackage}.{namespaceModule} <packageTarget>\n"
+              f"\t<packageTarget> is a path to a directory with Python modules\n"
+              f"\tExample: python -m {namespacePackage}.{namespaceModule} '{pathlib.PurePath('path' ,'to', 'Z0Z_tools')}'") 
+        # What is `-m`? Obviously, `-m` creates a namespace for the module, which is obviously necessary, except when it isn't.
+        sys.exit(1)
+
+    installPackageTarget(pathPackageTarget)
+    print(f"\n{pathlib.Path(__file__).stem} finished trying to trick pip into installing {pathPackageTarget.name}. Did it work?")
+
+def readability_counts() -> None:
+    """Brings the snark."""
+    everyone_knows_what___main___is()
+
+def main() -> None:
+    """Jabs subtly."""
+    readability_counts()
+
+if __name__ == "__main__":
+    main()

Z0Z_tools-0.5.2.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.1
+Name: Z0Z_tools
+Version: 0.5.2
+Summary: Audio processing, data structure, and package management tools.
+Project-URL: Homepage, https://github.com/hunterhogan/Z0Z_tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: packaging
+Requires-Dist: samplerate
+Requires-Dist: soundfile
+
+# Z0Z_tools
+
+"Z0Z_"- is a placeholder, and a Z0Z_tool is at best, a prototype.
+
+## Install an arbitrary package with `pipAnything`
+
+Try to install a package that doesn't have installation files.
+
+```sh
+python -m Z0Z_tools.pipAnything <pathPackage>
+```
+
+## Unpack and convert elements to `str` types with `stringItUp`
+
+## Merge and/or lightly clean a dictionary of lists with `updateExtendPolishDictionaryLists`
+
+- Merges multiple dictionaries of lists into a single dictionary.
+- Optionally remove duplicates each list.
+- Optionally sort each list.
+- Optionally delete data that won't merge.
+
+## Basic read/write WAV files with `readAudioFile` and `writeWav`
+
+The only option is the sample rate.
+
+## Use `loadWaveforms` to create one array of waveforms from multiple files
+
+## Install this package
+
+### From Github
+
+```sh
+pip install Z0Z_tools@git+https://github.com/hunterhogan/Z0Z_tools.git
+```
+
+### From a local directory
+
+#### Windows
+
+```powershell
+git clone https://github.com/hunterhogan/Z0Z_tools.git \path\to\Z0Z_tools
+pip install Z0Z_tools@file:\path\to\Z0Z_tools
+```
+
+#### POSIX
+
+```bash
+git clone https://github.com/hunterhogan/Z0Z_tools.git /path/to/Z0Z_tools
+pip install Z0Z_tools@file:/path/to/Z0Z_tools
+```
+
+## Install updates
+
+```sh
+pip install --upgrade Z0Z_tools@git+https://github.com/hunterhogan/Z0Z_tools.git
+```

Z0Z_tools-0.5.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+Z0Z_tools/Z0Z_dataStructure.py,sha256=_JAMowiDupWVTbRgonau8O8UTvZDHuNTk61EbX-a3R4,4098
+Z0Z_tools/Z0Z_io.py,sha256=OPwSM04xhyLTuGwhAR73i4UxmMC9tGS-z4d1HstXjUk,1229
+Z0Z_tools/Z0Z_ioAudio.py,sha256=L8F23JpGmG8KE-tDiRQsBgoJF2bPHYclk-K2w6CwzAU,5465
+Z0Z_tools/__init__.py,sha256=U6auRjRMpVKba_awePT9ipumvmnK6UB185_gHBQBucM,622
+Z0Z_tools/pipAnything.py,sha256=HenP4K_fBAdurrRGgKCFkS4HIqFNj6guw_BZl2tkjMU,6380
+unittests/test_Z0Z_dataStructure.py,sha256=mInwhLhX_9jaLy8IMPSt4Vfec9J14ntnbjHEvrTqeNo,14841
+unittests/test_ioAudio.py,sha256=nyOu_oY74uPQIwpR-JkhEJ1IinLjIt2_TiUmG-7qBgA,2736
+unittests/test_pipAnything.py,sha256=55QG_HoDVQQT9uvB43yLxVz-fY6rugv4ODcmsd9a_oU,2668
+Z0Z_tools-0.5.2.dist-info/METADATA,sha256=uZK7cJTYpumIeF3invq3pfgvbU2pcIAF-qtagarLOt4,1687
+Z0Z_tools-0.5.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+Z0Z_tools-0.5.2.dist-info/top_level.txt,sha256=0QGn7IRzNFffddo0Wg128tqn55DbM2H47940hEgqgFg,20
+Z0Z_tools-0.5.2.dist-info/RECORD,,

Z0Z_tools-0.5.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

Z0Z_tools-0.5.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+Z0Z_tools
+unittests

unittests/test_Z0Z_dataStructure.py

@@ -0,0 +1,340 @@
+from decimal import Decimal
+from fractions import Fraction
+from itertools import count, islice
+from Z0Z_tools.Z0Z_dataStructure import updateExtendPolishDictionaryLists, stringItUp
+import datetime
+import numpy
+import unittest
+import uuid
+
+class TestStringItUp(unittest.TestCase):
+
+    def test_empty_input(self):
+        self.assertEqual(stringItUp(), [])
+
+    def test_with_bytearray(self):
+        self.assertEqual(stringItUp(bytearray(b"bytearray")), ["bytearray(b'bytearray')"])
+
+    def test_with_generator(self):
+        def gen():
+            for i in range(3):
+                yield i
+        self.assertEqual(stringItUp(gen()), ['0', '1', '2'])
+
+    def test_with_infinite_iterator(self):
+        infinite_gen = count()
+        limited_gen = islice(infinite_gen, 5)
+        self.assertEqual(stringItUp(limited_gen), ['0', '1', '2', '3', '4'])
+
+    def test_with_object_with_custom_iter(self):
+        class CustomIter:
+            def __iter__(self):
+                return iter([1, 2, 3])
+        self.assertEqual(stringItUp(CustomIter()), ['1', '2', '3'])
+
+    def test_with_recursive_structure(self):
+        chicken_tikka_masala = []
+        chicken_tikka_masala.append(chicken_tikka_masala)
+        self.assertEqual(stringItUp(chicken_tikka_masala), ['[[...]]'])
+
+    def test_with_recursive_structure2(self):
+        chicken_tikka_masala = []
+        chicken_tikka_masala.append(chicken_tikka_masala)
+        self.assertEqual(stringItUp([chicken_tikka_masala, 'wazzup']), ["[[[...]], 'wazzup']"])
+
+    def test_with_nan_and_inf(self):
+        self.assertEqual(stringItUp(float('nan'), float('inf')), ['nan', 'inf'])
+
+    def test_with_large_numbers(self):
+        large_number = 10**100
+        self.assertEqual(stringItUp(large_number), [str(large_number)])
+
+    def test_with_decimal(self):
+        self.assertEqual(stringItUp(Decimal('1.1')), ['1.1'])
+
+    def test_with_fraction(self):
+        self.assertEqual(stringItUp(Fraction(1, 3)), ['1/3'])
+
+    def test_with_dates(self):
+        date = datetime.date(2021, 1, 1)
+        self.assertEqual(stringItUp(date), ['2021-01-01'])
+
+    def test_with_times(self):
+        time = datetime.time(12, 34, 56)
+        self.assertEqual(stringItUp(time), ['12:34:56'])
+
+    def test_with_datetime(self):
+        dt = datetime.datetime(2021, 1, 1, 12, 34, 56)
+        self.assertEqual(stringItUp(dt), ['2021-01-01 12:34:56'])
+
+    def test_with_uuid(self):
+        my_uuid = uuid.uuid4()
+        self.assertEqual(stringItUp(my_uuid), [str(my_uuid)])
+
+    def test_with_memoryview(self):
+        result = stringItUp(memoryview(b"memoryview"))
+        expected_prefix = "<memory at 0x"
+        self.assertTrue(result[0].startswith(expected_prefix))
+
+    def test_empty_iterable_types(self):
+        self.assertEqual(stringItUp([], (), set()), [])
+
+    def test_mixed_nested_iterables(self):
+        data = [1, (2, {3, "four"}), {"five": [6, 7]}]
+        self.assertCountEqual(stringItUp(data), ["1", "2", "3", "four", "five", "6", "7"])
+
+    def test_large_data(self):
+        large_list = list(range(1000))
+        result = stringItUp(large_list)
+        self.assertEqual(len(result), 1000)
+        for i in range(1000):
+            self.assertEqual(result[i], str(i))
+
+class TestUpdateExtendDictionaryLists(unittest.TestCase):
+
+    def test_with_mixed_types_in_values(self):
+        primus = {'a': [1, 'two'], 'b': [True, None]}
+        secundus = {'a': [3.14, 'four'], 'b': [False, 'none']}
+        expected = {
+            'a': [1, 'two', 3.14, 'four'],
+            'b': [True, None, False, 'none']
+        }
+        result = updateExtendPolishDictionaryLists(primus, secundus)
+        self.assertEqual(result, expected)
+
+    def test_with_non_string_keys(self):
+        primus = {None: [3], True: [2]}
+        secundus = {1: [1], (4, 5): [4]}
+        expected ={'(4, 5)': [4], '1': [1], 'None': [3], 'True': [2]}
+        result = updateExtendPolishDictionaryLists(primus, secundus) # type: ignore
+        self.assertEqual(result, expected)
+
+    def test_with_conflicting_data_types(self):
+        primus = {'a': 1, 'b': 2}
+        secundus = {'a': 3, 'c': 4}
+        with self.assertRaises(TypeError):
+            result = updateExtendPolishDictionaryLists(primus, secundus) # type: ignore
+
+    def test_with_kill_erroneous_data_types(self):
+        primus = {'a': [1, 2], 'b': [3, 4]}
+        secundus = {'a': 3, 'c': 4}
+        expected = {'a': [1, 2], 'b': [3, 4]}
+        result = updateExtendPolishDictionaryLists(primus, secundus, killErroneousDataTypes=True) # type: ignore
+        self.assertEqual(result, expected)
+
+    def test_basic_functionality(self):
+        primus = {'a': [3, 1], 'b': [2]}
+        secundus = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        expected = {'a': [3, 1, 9, 6, 1, 22, 3], 'b': [2, 111111, 2, 3]}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=False, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_ignore_list_ordering(self):
+        primus = {'a': [3, 1], 'b': [2]}
+        secundus = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        expected = {'a': [1, 1, 3, 3, 6, 9, 22], 'b': [2, 2, 3, 111111]}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=False, reorderLists=True)
+        self.assertEqual(result, expected)
+
+    def test_destroy_duplicates(self):
+        primus = {'a': [3, 1], 'b': [2]}
+        secundus = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        expected = {'a': [3, 1, 9, 6, 22], 'b': [2, 111111, 3]}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=True, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_secundus2(self):
+        secundus = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        expected = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        result = updateExtendPolishDictionaryLists({}, secundus, destroyDuplicates=False, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_secundus_ignore_list_ordering2(self):
+        secundus = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        expected = {'a': [1, 3, 6, 9, 22], 'b': [2, 3, 111111]}
+        result = updateExtendPolishDictionaryLists({}, secundus, destroyDuplicates=False, reorderLists=True)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_secundus_destroy_duplicates2(self):
+        secundus = {'a': [9, 6, 1, 22, 3, 9], 'b': [111111, 2, 3, 2]}
+        expected = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        result = updateExtendPolishDictionaryLists({}, secundus, destroyDuplicates=True, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_secundus_destroy_duplicates_ignore_list_ordering2(self):
+        secundus = {'a': [9, 6, 1, 22, 3, 9], 'b': [111111, 2, 3, 2]}
+        expected = {'a': [1, 3, 6, 9, 22], 'b': [2, 3, 111111]}
+        result = updateExtendPolishDictionaryLists({}, secundus, destroyDuplicates=True, reorderLists=True)
+        self.assertEqual(result, expected)
+
+    def test_empty_dictionaries(self):
+        primus = {}
+        secundus = {}
+        expected = {}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=False, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_empty_and_non_empty_dictionary(self):
+        primus = {}
+        secundus = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        expected = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=False, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_non_empty_and_empty_dictionary(self):
+        primus = {'a': [3, 1], 'b': [2]}
+        secundus = {}
+        expected = {'a': [3, 1], 'b': [2]}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=False, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_empty_dictionaries_with_options(self):
+        primus = {}
+        secundus = {}
+        expected = {}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=True, reorderLists=True)
+        self.assertEqual(result, expected)
+
+    def test_single_empty_dictionary(self):
+        primus = {}
+        expected = {}
+        result = updateExtendPolishDictionaryLists(primus, destroyDuplicates=False, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_single_empty_dictionary_with_options(self):
+        primus = {}
+        expected = {}
+        result = updateExtendPolishDictionaryLists(primus, destroyDuplicates=True, reorderLists=True)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_primus(self):
+        primus = {'a': [3, 1], 'b': [2]}
+        expected = {'a': [3, 1], 'b': [2]}
+        result = updateExtendPolishDictionaryLists(primus, destroyDuplicates=False, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_primus_ignore_list_ordering_variant(self):
+        primus = {'a': [3, 1], 'b': [2]}
+        expected = {'a': [1, 3], 'b': [2]}
+        result = updateExtendPolishDictionaryLists(primus, destroyDuplicates=False, reorderLists=True)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_primus_destroy_duplicates_ignore_list_ordering_variant(self):
+        primus = {'a': [3, 1, 3], 'b': [2, 2]}
+        expected = {'a': [3, 1], 'b': [2]}
+        result = updateExtendPolishDictionaryLists(primus, destroyDuplicates=True, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_primus_destroy_duplicates_ignore_list_ordering(self):
+        primus = {'a': [3, 1, 3], 'b': [2, 2]}
+        expected = {'a': [1, 3], 'b': [2]}
+        result = updateExtendPolishDictionaryLists(primus, destroyDuplicates=True, reorderLists=True)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_secundus(self):
+        secundus = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        expected = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        result = updateExtendPolishDictionaryLists(secundus, destroyDuplicates=False, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_secundus_ignore_list_ordering(self):
+        secundus = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        expected = {'a': [1, 3, 6, 9, 22], 'b': [2, 3, 111111]}
+        result = updateExtendPolishDictionaryLists(secundus, destroyDuplicates=False, reorderLists=True)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_secundus_destroy_duplicates(self):
+        secundus = {'a': [9, 6, 1, 22, 3, 9], 'b': [111111, 2, 3, 2]}
+        expected = {'a': [9, 6, 1, 22, 3], 'b': [111111, 2, 3]}
+        result = updateExtendPolishDictionaryLists(secundus, destroyDuplicates=True, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_single_dictionary_secundus_destroy_duplicates_ignore_list_ordering(self):
+        secundus = {'a': [9, 6, 1, 22, 3, 9], 'b': [111111, 2, 3, 2]}
+        expected = {'a': [1, 3, 6, 9, 22], 'b': [2, 3, 111111]}
+        result = updateExtendPolishDictionaryLists(secundus, destroyDuplicates=True, reorderLists=True)
+        self.assertEqual(result, expected)
+
+    def test_with_sets(self):
+        primus = {'a': {3, 1}, 'b': {2}}
+        secundus = {'a': {9, 6, 1, 22, 3}, 'b': {111111, 2, 3}}
+        expected = {'a': [3, 1, 9, 6, 22], 'b': [2, 111111, 3]}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=True, reorderLists=False) # type: ignore
+        self.assertCountEqual(result['a'], expected['a'])
+
+    def test_with_tuples(self):
+        primus = {'a': (3, 1), 'b': (2,)}
+        secundus = {'a': (9, 6, 1, 22, 3), 'b': (111111, 2, 3)}
+        expected = {'a': [3, 1, 9, 6, 1, 22, 3], 'b': [2, 111111, 2, 3]}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=False, reorderLists=False)
+        self.assertEqual(result, expected)
+
+    def test_with_ndarray(self):
+        primus = {'a': numpy.array([3, 1]), 'b': numpy.array([2])}
+        secundus = {'a': numpy.array([9, 6, 1, 22, 3]), 'b': numpy.array([111111, 2, 3])}
+        expected = {'a': [3, 1, 9, 6, 1, 22, 3], 'b': [2, 111111, 2, 3]}
+        result = updateExtendPolishDictionaryLists(primus, secundus, destroyDuplicates=False, reorderLists=False) # type: ignore
+        self.assertEqual(result, expected)
+
+    def test_empty_input(self):
+        self.assertEqual(stringItUp(), [])
+
+    def test_single_string(self):
+        self.assertEqual(stringItUp("hello"), ["hello"])
+
+    def test_single_integer(self):
+        self.assertEqual(stringItUp(123), ["123"])
+
+    def test_single_float(self):
+        self.assertEqual(stringItUp(3.14), ["3.14"])
+
+    def test_single_list(self):
+        self.assertCountEqual(stringItUp([1, 2, "three"]), ["1", "2", "three"])
+
+    def test_single_tuple(self):
+        self.assertCountEqual(stringItUp((1, 2, "three")), ["1", "2", "three"])
+
+    def test_single_set(self):
+        self.assertCountEqual(stringItUp({1, 2, "three"}), ["1", "2", "three"])
+
+    def test_single_dict(self):
+        self.assertCountEqual(stringItUp({"a": 1, "b": "two"}), ["a", "1", "b", "two"])
+
+    def test_nested_list(self):
+        self.assertCountEqual(stringItUp([1, [2, "three"], 4]), ["1", "2", "three", "4"])
+
+    def test_nested_tuple(self):
+        self.assertCountEqual(stringItUp((1, (2, "three"), 4)), ["1", "2", "three", "4"])
+
+    def test_nested_set(self):
+        self.assertCountEqual(stringItUp({1, frozenset({2, "three"}), 4}), ["1", "2", "three", "4"])
+
+    def test_nested_dict(self):
+        self.assertCountEqual(stringItUp({"a": 1, "b": {"c": 2, "d": "three"}}), ["a", "1", "b", "c", "2", "d", "three"])
+
+    def test_mixed_data_types(self):
+        self.assertCountEqual(stringItUp(1, "two", [3, "four"], {"five": 5}), ["1", "two", "3", "four", "five", "5"])
+
+    def test_with_numpy_array(self):
+        self.assertCountEqual(stringItUp(numpy.array([1, 2, 3])), ["1", "2", "3"])
+
+    def test_with_custom_object(self):
+        class MyObject:
+            def __str__(self):
+                return "MyObject"
+        self.assertEqual(stringItUp(MyObject()), ["MyObject"])
+
+    def test_with_none(self):
+        self.assertEqual(stringItUp(None), ["None"])
+
+    def test_with_boolean(self):
+        self.assertCountEqual(stringItUp(True, False), ["True", "False"])
+
+    def test_with_complex_number(self):
+        self.assertEqual(stringItUp(1+2j), ["(1+2j)"])
+
+    def test_with_bytes(self):
+        self.assertEqual(stringItUp(b"bytes"), ["b'bytes'"])
+
+if __name__ == '__main__':
+    unittest.main()

unittests/test_ioAudio.py

@@ -0,0 +1,59 @@
+from Z0Z_tools import readAudioFile, loadWaveforms
+import numpy
+import pathlib 
+import unittest
+
+class TestReadAudioFile(unittest.TestCase):
+
+    def setUp(self):
+        self.test_data_dir = pathlib.Path("unittests/dataSamples")
+        self.mono_file = self.test_data_dir / "testWooWooMono16kHz32integerClipping9sec.wav"
+        self.stereo_file = self.test_data_dir / "testSine2ch5sec.wav"
+        self.non_audio_file = self.test_data_dir / "testVideo11sec.mkv"
+
+    def test_read_mono_audio_file(self):
+        waveform = readAudioFile(self.mono_file)
+        self.assertIsInstance(waveform, numpy.ndarray)
+        self.assertEqual(waveform.ndim, 2)  # Mono should have 1 dimension
+
+    def test_read_stereo_audio_file(self):
+        waveform = readAudioFile(self.stereo_file)
+        self.assertIsInstance(waveform, numpy.ndarray)
+        self.assertEqual(waveform.ndim, 2)  # Stereo should have 2 dimensions
+        self.assertEqual(waveform.shape[0], 2)  # First dimension should be 2 for stereo
+
+class TestLoadWaveforms(unittest.TestCase):
+
+    def test_load_waveforms_mono(self):
+        """Test loading mono waveforms with different sample rates."""
+        path_filenames = [
+            pathlib.Path("unittests/dataSamples/testWooWooMono16kHz32integerClipping9secCopy1.wav"),
+            pathlib.Path("unittests/dataSamples/testWooWooMono16kHz32integerClipping9secCopy2.wav"),
+            pathlib.Path("unittests/dataSamples/testWooWooMono16kHz32integerClipping9secCopy3.wav"),
+        ]
+        array_waveforms = loadWaveforms(path_filenames, sampleRate=44100)
+        self.assertEqual(array_waveforms.shape, (2, 396900, 3))
+
+    def test_load_waveforms_stereo(self):
+        """Test loading stereo waveforms with different sample rates."""
+        path_filenames = [
+            pathlib.Path("unittests/dataSamples/testSine2ch5secCopy1.wav"),
+            pathlib.Path("unittests/dataSamples/testSine2ch5secCopy2.wav"),
+            pathlib.Path("unittests/dataSamples/testSine2ch5secCopy3.wav"),
+            pathlib.Path("unittests/dataSamples/testSine2ch5secCopy4.wav"),
+        ]
+        array_waveforms = loadWaveforms(path_filenames, sampleRate=44100)
+        self.assertEqual(array_waveforms.shape, (2, 220500, 4))
+
+    def test_load_waveforms_mixed_channels(self):
+        """Test loading a mix of mono and stereo waveforms."""
+        path_filenames = [
+            pathlib.Path("unittests/dataSamples/testWooWooMono16kHz32integerClipping9sec.wav"),
+            pathlib.Path("unittests/dataSamples/testSine2ch5sec.wav")
+        ]
+        array_waveforms = loadWaveforms(path_filenames, sampleRate=44100)
+        self.assertEqual(array_waveforms.shape, (2, 396900, 2))
+
+
+if __name__ == "__main__":
+    unittest.main()

unittests/test_pipAnything.py

@@ -0,0 +1,59 @@
+from pathlib import Path
+from unittest.mock import patch
+from Z0Z_tools import pipAnything
+import tempfile
+import unittest
+
+class TestPipAnything(unittest.TestCase):
+
+    def test_makeListRequirementsFromRequirementsFile(self):
+        """
+        Test the makeListRequirementsFromRequirementsFile function.
+        """
+        with tempfile.TemporaryDirectory() as tempdir:
+            # Create a temporary requirements file
+            requirements_file = Path(tempdir) / 'requirements.txt'
+            requirements_content = """
+            # This is a comment
+            package-A==1.2.3
+            package-B>=4.5.6,<=7.8.9
+            package_C
+            # Another comment
+            analyzeAudio@git+https://github.com/hunterhogan/analyzeAudio.git
+            """
+            requirements_file.write_text(requirements_content)
+
+            # Test with a single file
+            requirements = pipAnything.makeListRequirementsFromRequirementsFile(requirements_file)
+            self.assertEqual(len(requirements), 4)
+            self.assertIn('package-A==1.2.3', requirements)
+            self.assertIn('package-B>=4.5.6,<=7.8.9', requirements)
+            self.assertIn('package_C', requirements)
+            self.assertIn('analyzeAudio@git+https://github.com/hunterhogan/analyzeAudio.git', requirements)
+
+            # Test with multiple files
+            requirements2 = pipAnything.makeListRequirementsFromRequirementsFile(requirements_file, requirements_file)
+            self.assertEqual(len(requirements2), 4)  # Should still be 4, duplicates removed
+
+            # Test with non-existent file
+            nonexistent_file = Path(tempdir) / 'nonexistent.txt'
+            requirements3 = pipAnything.makeListRequirementsFromRequirementsFile(nonexistent_file)
+            self.assertEqual(len(requirements3), 0)  # Should be empty
+
+    def test_make_setupDOTpy(self):
+        """
+        Test the make_setupDOTpy function.
+        """
+        relative_path_package = 'my_package'
+        list_requirements = ['numpy', 'pandas']
+        setup_content = pipAnything.make_setupDOTpy(relative_path_package, list_requirements)
+
+        # Check if the generated content contains expected elements
+        self.assertIn(f"name='{Path(relative_path_package).name}'", setup_content)
+        self.assertIn(f"packages=find_packages(where=r'{relative_path_package}')", setup_content)
+        self.assertIn(f"package_dir={{'': r'{relative_path_package}'}}", setup_content)
+        self.assertIn(f"install_requires={list_requirements},", setup_content)
+        self.assertIn("include_package_data=True", setup_content)
+
+if __name__ == '__main__':
+    unittest.main()