kisspy-python 1.0.1__py3-none-any.whl

kisspy/__init__.py

@@ -0,0 +1,7 @@
+from kisspy.converters.numericConverter import toNumeric, raiseValExc, returnNone, returnTxt
+from kisspy.xtdPy.dt.timeFormatting import getSortableNow, SORTABLE_DT_FRMT, SORTABLE_DT_TZA_FRMT
+from kisspy.xtdPy.paths.directories import splitPath, expandUser, createDir
+from kisspy.xtdPy.strings.textExtensions import randomString
+from kisspy.xtdPy.dicts import getValueOfPath, setValueOfPath, addToDictIfExists
+from kisspy.xtdPy.lists import appendUnique, assertOne
+from kisspy.xtdPy.json import dumpData, loadData, createAndReturnDefault

kisspy/_metadata.json

@@ -0,0 +1,21 @@
+
+{
+    "name": "kisspy-python",
+    "version": "1.0.1",
+    "author": "Joe Marchionna",
+    "author_email": "joemarchionna@gmail.com",
+    "description": "Simple Python Scripting Helpers",
+    "requirements": "requirements/prod.txt",
+    "url": "https://github.com/joemarchionna/kisspy",
+    "packageData":
+    {
+        "kisspy": [
+            "*.json"
+        ]
+    },
+    "classifiers": [
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+        "Intended Audience :: Developers"
+    ]
+}

kisspy/converters/__init__.py

@@ -0,0 +1,2 @@
+from kisspy.converters.numericConverter import toNumeric, raiseValExc, returnNone, returnTxt
+from kisspy.converters.excelHelpers import toExcelCol, fromExcelCol

kisspy/converters/excelHelpers.py

@@ -0,0 +1,26 @@
+from functools import reduce
+import string
+
+# https://stackoverflow.com/questions/48983939/convert-a-number-to-excel-s-base-26
+# this works for SBS plates as well
+
+
+def _divmod_excel(n):
+    a, b = divmod(n, 26)
+    if b == 0:
+        return a - 1, b + 26
+    return a, b
+
+
+def toExcelCol(columnNum: int) -> str:
+    """converts a 1-based column number to Excel column name, ie: 27 -> AA"""
+    chars = []
+    while columnNum > 0:
+        columnNum, d = _divmod_excel(columnNum)
+        chars.append(string.ascii_uppercase[d - 1])
+    return "".join(reversed(chars))
+
+
+def fromExcelCol(columnName: str) -> int:
+    """converts an Excel column name to a 1-based integer, ie: AA -> 27"""
+    return reduce(lambda r, x: r * 26 + x + 1, map(string.ascii_uppercase.index, columnName), 0)

kisspy/converters/numericConverter.py

@@ -0,0 +1,32 @@
+def raiseValExc(*args, **kwargs):
+    """raises a ValueError with the first argument displayed in single quotes as part of the error message"""
+    msg = "The Value '{}' Could Not Be Converted To A Numeric Value".format(args[0])
+    args[1].add_note(msg)
+    raise args[1]
+
+
+def returnNone(*args, **kwargs) -> None:
+    """returns Python None variable regardless of arguments passed"""
+    return None
+
+
+def returnTxt(*args, **kwargs) -> None:
+    """returns the first argument, does nothing else"""
+    return args[0]
+
+
+def toNumeric(val, onFail=returnNone) -> float | int | None:
+    """
+    returns a float or int, by converting the provided val\n
+    \t to a float and if possible, an int\n
+    on error, it calls onFail providing val as the first parameter\n
+    \t by default, returns None
+    """
+    try:
+        if isinstance(val, str):
+            val = float(val)
+        if int(val) == val:
+            return int(val)
+        return val
+    except ValueError as verr:
+        return onFail(val, verr)

kisspy/decorators/pidFile.py

@@ -0,0 +1,32 @@
+from kisspy.exceptions import PidFilePresentException
+from functools import wraps
+import os
+
+PID_FN = "wkdir/appPID.txt"
+
+
+def pidFile(filename: str = PID_FN):
+    """
+    will allow method decorated to run only if the pid file specified is not present\n
+    if filename is set to None this will have no effect (will allow multiple instances)
+    """
+
+    def pidFileDecorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                if filename:
+                    if os.path.exists(filename):
+                        raise PidFilePresentException("Method Already Running!")
+                    with open(filename, "w") as wtr:
+                        wtr.write("{}\n".format(os.getpid()))
+                results = func(*args, **kwargs)
+                if filename:
+                    os.remove(filename)
+                return results
+            except PidFilePresentException as pidErr:
+                print("{}: {}".format(PidFilePresentException.__name__, pidErr))
+
+        return wrapper
+
+    return pidFileDecorator

kisspy/decorators/singleton.py

@@ -0,0 +1,18 @@
+def singleton(_class):
+    """
+    class decorator to create a single instance of a class;\n
+    usage:\n
+
+    @singleton\n
+    class MyClass(<baseClass>):\n
+        pass
+
+    """
+    _instances = {}
+
+    def _getinstance(*args, **kwargs):
+        if _class not in _instances:
+            _instances[_class] = _class(*args, **kwargs)
+        return _instances[_class]
+
+    return _getinstance

kisspy/decorators/thrdSafeSync.py

@@ -0,0 +1,20 @@
+import threading
+
+
+def thrdSafeSync(func):
+    """
+    decorator that makes the function thread safe\n
+    example:\n
+    ```python
+    @thrdSafeSync
+    def oneAtATime():
+        file IO process...
+    ```
+    """
+    lock = threading.Lock()  # A lock for this specific function
+
+    def wrapper(*args, **kwargs):
+        with lock:  # Acquire and release the lock using 'with' statement
+            return func(*args, **kwargs)
+
+    return wrapper

kisspy/exceptions.py

@@ -0,0 +1,29 @@
+class KisspyException(Exception):
+    def toStrWithTyp(self) -> str:
+        return "{}: {}".format(type(self).__name__, self)
+
+
+class PidFilePresentException(KisspyException):
+    pass
+
+
+class TooManyRecordsException(KisspyException):
+    MSG_FORMAT = "{} {} Returned, {} Were Expected"
+
+    def __init__(self, *args: object, numberRecords: int = None, recordType: str = "Records", numberExpected: int = 1) -> None:
+        if numberRecords and recordType:
+            msg = TooManyRecordsException.MSG_FORMAT.format(numberRecords, recordType, numberExpected)
+            super().__init__(msg, *args)
+        else:
+            super().__init__(*args)
+
+
+class ZeroRecordsException(KisspyException):
+    MSG_FORMAT = "Zero (0) {} Returned, > 0 Were Expected"
+
+    def __init__(self, *args, recordType: str = "Records"):
+        if args:
+            super().__init__(*args)
+        else:
+            msg = ZeroRecordsException.MSG_FORMAT.format(recordType)
+            super().__init__(msg, *args)

kisspy/metaclasses/singleton.py

@@ -0,0 +1,16 @@
+class Singleton(type):
+    """
+    meta-class to create a single instance of a class;\n
+    usage:\n
+
+    class MyClass(<baseClass>, metaclass=Singleton):\n
+        pass
+
+    """
+
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]

kisspy/xtdPy/dicts.py

@@ -0,0 +1,63 @@
+import json
+
+
+def getValueOfPath(data: dict, keyPath: str, defaultValue=None):
+    """
+    returns the value at the key path provided;\n
+    data: dict, the dictionary to evaluate, ie: {'animals':{'dogs':{'whippet':'fast'}}};\n
+    keyPath: str, key 'tree' to work down using '/' as separators, ie: 'animals/dogs/whippet' returns 'fast';\n
+    defaultValue: any, default value returned if the path is not found
+    """
+    mKeys = keyPath.split("/")
+    dval = dict(data)
+    for k in mKeys:
+        dval = dval.get(k, None)
+        if dval is None:
+            dval = defaultValue
+            break
+    return dval
+
+
+def setValueOfPath(data: dict, keyPath: str, value, createTree: bool = True) -> bool:
+    """
+    sets the value provided to the last key in the path\n
+    returns true if the value was able to be set, false if any of the tree was not a dict and therefore unable to be set\n
+    if createTree is true, it creates a dict if any key in the path does not exist, otherwise does not set the value and exits
+    """
+    if not keyPath:
+        return False
+    pKeys = keyPath.split("/")
+    dval = data
+    for i, k in enumerate(pKeys):
+        if not isinstance(dval, dict):
+            return False
+        if (i + 1) < len(pKeys):
+            if (k not in dval) and createTree:
+                dval[k] = {}
+            dval = dval.get(k, None)
+        else:
+            dval[k] = value
+            return True
+    return False
+
+
+def deepCopy(data):
+    """
+    returns a true deep copy of the original data object by serializing to JSON and back again
+    """
+    jStr = json.dumps(data)
+    return json.loads(jStr)
+
+
+def addToDictIfExists(destination: dict, fieldName: str, fieldValue, normalizeTxtTo: str = None):
+    """
+    adds the fieldvalue assigned to the fieldname key in the destination dictionary, if the fieldvalue is not 'None'\n
+    if normalizeTxtTo is a callable function, it will call that function when setting, ie: 'lower'
+    """
+    if fieldValue:
+        if isinstance(fieldValue, str) and normalizeTxtTo:
+            mthd = getattr(fieldValue, normalizeTxtTo)
+            if callable(mthd):
+                fieldValue = mthd()
+        destination[fieldName] = fieldValue
+    return destination

kisspy/xtdPy/dt/timeFormatting.py

@@ -0,0 +1,21 @@
+import datetime
+
+SORTABLE_DT_FRMT = "%Y%m%d.%H%M%S"
+SORTABLE_DT_TZA_FRMT = "%Y%m%d.%H%M%S%z"
+PYLOG_DT_FRMT = "%Y-%m-%d %H:%M:%S,%f"
+
+
+def getSortableNow(prefix=None, suffix=None, frmt: str = SORTABLE_DT_FRMT):
+    """
+    returns the date and time as a sortable string separated by a period ie: 'YYYYmmdd.HHMMSS' or the format provided;\n
+    prefix: str added before sortable date/time;\n
+    suffix: str added after sortable date/time;\n
+    frmt: str, format to output datetime as
+    """
+    val = ""
+    if prefix:
+        val = prefix
+    val = val + datetime.datetime.now().strftime(frmt)
+    if suffix:
+        val = val + suffix
+    return val

kisspy/xtdPy/json.py

@@ -0,0 +1,80 @@
+import logging
+import pathlib
+import json
+import os
+
+_logger = logging.getLogger(__name__)
+_logger.addHandler(logging.NullHandler())
+
+
+def returnNone(*args, **kwargs):
+    _logger.debug("No Data Provided, Returning None (Not Saving)")
+    return None
+
+
+def dumpData(filename: str, data: dict | list, onNoData=returnNone) -> str:
+    """
+    dumps the data to the filename specified, creating parent directories if neccessary
+
+    Args:
+        filename (str): filename, including path
+        data (dict | list): the data to dump to JSON
+        onNoData (callable, optional): a method expecting the filename and data as args, in that order. Defaults to returnNone
+
+    Returns:
+        str: filename
+    """
+    if not data:
+        return onNoData(filename, data)
+    pathlib.Path(os.path.split(filename)[0]).mkdir(parents=True, exist_ok=True)
+    with open(filename, "w") as wtr:
+        json.dump(data, wtr, indent=4)
+    return filename
+
+
+def returnDefault(*args, **kwargs) -> dict:
+    """
+    returns the JSON data\n
+    expects the filename and data as args, in that order
+
+    Returns:
+        dict | list: JSON data
+    """
+    _logger.debug("'{}' Does Not Exist, Returning Default Data".format(args[0]))
+    return args[1]
+
+
+def createAndReturnDefault(*args, **kwargs) -> dict:
+    """
+    saves the JSON data to the path provided and returns the data\n
+    expects the filename and data as args, in that order
+
+    Returns:
+        dict | list: JSON data
+    """
+    _logger.debug("'{}' Did Not Exist, Saved And Returning Default Data".format(args[0]))
+    dumpData(args[0], args[1])
+    return args[1]
+
+
+def loadData(filename: str, defaultData=None, onNotExist=returnDefault) -> dict | list:
+    """
+    loads json data from the file specified
+
+    Args:
+        filename (str): filename
+        defaultData (dict | list, optional): if the filename is not present, this value is passed to the onNotExist callable. Defaults to None
+        onNotExist (callable, optional): a method expecting the filename and default data as args, in that order. Defaults to returnDefault
+
+    Returns:
+        dict | list: the JSON data in the file or defaultData
+    """
+    if not filename:
+        _logger.debug("No Filename Provided, Returning Default Data")
+        return defaultData
+    if not os.path.exists(filename):
+        if onNotExist:
+            return onNotExist(filename, defaultData)
+        return defaultData
+    with open(filename) as rdr:
+        return json.load(rdr)

kisspy/xtdPy/lists.py

@@ -0,0 +1,95 @@
+from kisspy.exceptions import TooManyRecordsException
+
+NO_VALUE = "__no_value__"
+
+
+def binRecordsOnKey(elements: list[dict], key: str, noKeyOrValue: str = NO_VALUE) -> list[list[dict]]:
+    """
+    returns a list within a list where the internal lists are binned based on the values of the key in the original list\n
+    will bin missing or null values together; to not bin null or missing key records, set noKeyOrValue = None\n
+    ie:\n
+    i = [{'a':1},{'a':2},{'a':2},{'a':1},{'a':4},{'a':1},{'a':5}]\n
+    z = binRecordsOnKey(i, 'a')\n
+    z is [ \n
+        [{'a':1},{'a':1},{'a':1}], \n
+        [{'a':2},{'a':2}], \n
+        [{'a':4}], \n
+        [{'a':5}] \n
+    ]
+    """
+    uniqueKeyValues = []
+    for e in elements:
+        kv = e.get(key, noKeyOrValue)
+        if kv and (kv not in uniqueKeyValues):
+            uniqueKeyValues.append(kv)
+    dividedLists = []
+    for ukv in uniqueKeyValues:
+        dividedLists.append([x for x in elements if x.get(key, noKeyOrValue) == ukv])
+    return dividedLists
+
+
+def appendUnique(lst: list, obj) -> bool:
+    """
+    appends the object provided to the list provided IF the object is not in the list already\n
+    lst: list, the list to append the value to\n
+    obj: object, the object to append to the list\n
+    returns True if the object was appended to the list, otherwise False
+    """
+    if obj in lst:
+        return False
+    lst.append(obj)
+    return True
+
+
+def thrwMultiRcdExc(*args, **kwargs):
+    raise TooManyRecordsException(numberRecords=len(args[0]))
+
+
+def assertOne(records: list, onZeroRcds=None, onMultiRcds=thrwMultiRcdExc) -> dict | list:
+    """
+    if the list has only one record, returns the only record\n
+    if the list is empty or None, returns the result of the\n
+     onZeroRcds callable if provided else None\n
+    if the length of the list is greater than one, returns the\n
+     result of the onMultiRcds callable if provided else the original\n
+     list; default action is raise an TooManyRecordsException\n
+    the callables are passed the records list as an arg
+    """
+    if not records:
+        if onZeroRcds:
+            return onZeroRcds(records)
+        return None
+    if len(records) > 1:
+        if onMultiRcds:
+            return onMultiRcds(records)
+        return records
+    return records[0]
+
+
+# def _cleanValue(value, caseSensitive=False):
+#     if not isinstance(value, str):
+#         return None
+#     value = value.strip()
+#     if not caseSensitive:
+#         value = value.lower()
+#     return value
+
+
+# def getExactMatches(
+#     records: list[dict], keyName: str, compareTo: str, caseSensitive=False, onCleanValue=_cleanValue
+# ) -> list[dict]:
+#     """
+#     returns a list of records where the keyName's value matches the compareTo value\n
+#     recordList: list, the list to evaluate\n
+#     keyName: str, the dict key of each record to compare compareTo to\n
+#     compareTo: str, the value to compare to\n
+#     caseSensitive: bool, if False (default), comparison is done case-insensitive and vice-versa\n
+#     onCleanValue: callable, method to call to clean the value
+#     """
+#     exactMatches = []
+#     compareTo = onCleanValue(compareTo, caseSensitive)
+#     for r in records:
+#         v = onCleanValue(r.get(keyName, None), caseSensitive)
+#         if v and (v == compareTo):
+#             exactMatches.append(r)
+#     return exactMatches

kisspy/xtdPy/paths/_common.py

@@ -0,0 +1,20 @@
+def addEndingSeparator(path: str, sep: str = "/") -> str:
+    """ensure the path ends in the separator specified"""
+    if path.endswith(sep):
+        return path
+    return path + sep
+
+
+def removeEndingSeparator(path: str, sep: str = "/") -> str:
+    """ensure the path does not end in the separator specified"""
+    if not path.endswith(sep):
+        return path
+    return path[: (len(path) - 1)]
+
+
+def frmtPath(path: str, convertToFwdSlsh: bool, endInSeparator: bool) -> str:
+    if convertToFwdSlsh:
+        path = path.replace("\\", "/")
+    if endInSeparator:
+        path = addEndingSeparator(path)
+    return path

kisspy/xtdPy/paths/directories.py

@@ -0,0 +1,43 @@
+from kisspy.xtdPy.paths._common import frmtPath
+from typing import Tuple
+import pathlib
+import os
+
+
+def _createDir(directory: str) -> bool:
+    if os.path.exists(directory):
+        return False
+    pathlib.Path(directory).mkdir(parents=True, exist_ok=True)
+    return True
+
+
+def splitPath(filename: str, convertToFwdSlsh: bool = True, endInSeparator: bool = True) -> Tuple[str, str]:
+    d, f = os.path.split(filename)
+    d = frmtPath(d, convertToFwdSlsh, endInSeparator)
+    return d, f
+
+
+def createDir(fqFilename: str, directory: str = None, convertToFwdSlsh: bool = True, endInSeparator: bool = True) -> str:
+    """
+    creates the parent directories if they do not exist;\n
+    takes either filename (including directories) or directory parameter\n
+    returns the directory
+    """
+    if fqFilename:
+        directory, f = splitPath(fqFilename, convertToFwdSlsh, endInSeparator)
+    else:
+        directory = frmtPath(directory, convertToFwdSlsh, endInSeparator)
+    _createDir(directory)
+    return directory
+
+
+def expandUser(path: str, expandChar: str = "~", convertToFwdSlsh: bool = True, endInSeparator: bool = False) -> str:
+    """
+    expands the path to a fully qualified path using the expandChar as a signal to do so\n
+    replaces back slashes to forward slashes if convertToFwdSlsh is true\n
+    returns the path as a simple string
+    """
+    if not path or not path.startswith(expandChar):
+        return path
+    homeDir = frmtPath(str(pathlib.Path.home()), convertToFwdSlsh, endInSeparator)
+    return path.replace(expandChar, homeDir)

kisspy/xtdPy/paths/files.py

@@ -0,0 +1,48 @@
+from kisspy.xtdPy.paths.directories import expandUser
+from kisspy.xtdPy.json import loadData
+from typing import Tuple
+import datetime
+import pathlib
+import logging
+import os
+
+_logger = logging.getLogger(__name__)
+_logger.addHandler(logging.NullHandler())
+
+
+def lastModifiedDT(fqFilename) -> datetime.datetime:
+    """returns a datetime object for the file specified, or None if it fails"""
+    try:
+        pth = pathlib.Path(fqFilename)
+        return datetime.datetime.fromtimestamp(pth.stat().st_mtime)
+    except:
+        return None
+
+
+def _getFn(directory: str, fn: str) -> str:
+    """returns a string as the filepath"""
+    return "{}/{}".format(expandUser(directory), fn)
+
+
+def searchForFile(filename: str, locations: list[str]) -> str:
+    """
+    searches for a file in the locations provided and returns the fn\n
+    locations can include the home directory designation '~'
+    """
+    for fn in [_getFn(x, filename) for x in locations]:
+        _logger.debug("Searching For File '{}'".format(fn))
+        if os.path.exists(fn) and os.path.isfile(fn):
+            return fn
+    return None
+
+
+def searchAndload(filename: str, directories: list[str], defaultData=None) -> Tuple[str, dict]:
+    """
+    searches for a file in the format location/appName/filename and returns the fn and loaded json content\n
+    directories can include the home directory designation '~'
+    """
+    fn = searchForFile(filename, directories)
+    if fn:
+        _logger.debug("Found File '{}'".format(fn))
+        return fn, loadData(fn, defaultData)
+    return None, defaultData

kisspy/xtdPy/strings/base64data.py

@@ -0,0 +1,32 @@
+import base64
+
+
+def fromFile(filename):
+    """
+    returns a string representing the file contents in Base64
+    """
+    with open(filename, "rb") as image_file:
+        data = base64.b64encode(image_file.read()).decode("utf-8")
+    return data
+
+
+def fromBytes(bytes):
+    """
+    returns a string representing the bytes in Base64
+    """
+    return base64.b64encode(bytes).decode("utf-8")
+
+
+def toBytes(base64str):
+    """
+    writes Base64 string back to original binary encoding
+    """
+    return base64.b64decode(base64str)
+
+
+def toFile(filename, base64str):
+    """
+    writes Base64 string back to original binary encoded file
+    """
+    with open(filename, "wb") as writer:
+        writer.write(base64.b64decode(base64str))

kisspy/xtdPy/strings/textExtensions.py

@@ -0,0 +1,41 @@
+import os
+import re
+
+
+def randomString(size=5) -> str:
+    """
+    returns a random string of length size
+
+    Args:
+        size (int, optional): length of the string returned. Defaults to 5
+
+    Returns:
+        str: random string
+    """
+    return str(os.urandom(size).hex())[:size]
+
+
+def replaceChars(source: str, remove: str, replaceWith: str = ""):
+    """
+    cleans and returns a string by replacing / removing chars;\n
+    source: str, the source string to clean;\n
+    remove: str, string containing any chars to remove from the source string;\n
+    replaceWith: str, the string to put in place of any char found, empty (remove) or not empty (replace)
+    """
+    removeRe = remove.replace("[", r"\[").replace("]", r"\]")
+    removeRe = "[{}]".format(removeRe)
+    result = re.sub(removeRe, replaceWith, source)
+    return result
+
+
+def cleanAndNormalize(source: str, remove=" %:,[]<>*?", replaceWith: str = "_"):
+    """
+    cleans a string, works great for a filename
+    """
+    cfn = replaceChars(source=source, remove=remove, replaceWith=replaceWith)
+    if replaceWith:
+        endsPattern = "(^" + replaceWith + ")|(" + replaceWith + "$)"
+        cfn = re.sub(endsPattern, "", cfn)
+        multiPattern = "([" + replaceWith + "]{2})"
+        cfn = re.sub(multiPattern, replaceWith, cfn)
+    return cfn

kisspy/xtdPy/strings/textNormalizer.py

@@ -0,0 +1,103 @@
+import unidecode
+import logging
+import re
+
+SPACE_BEFORE = r"(["
+SPACE_AFTER = r")];,"
+NO_SPACE_BEFORE = r")]/\-;,"
+NO_SPACE_AFTER = r"([/\-"
+
+_logger = logging.getLogger(__name__)
+_logger.addHandler(logging.NullHandler())
+
+
+def _createSeq(chars: str, addSpace: bool, before: bool):
+    d = {}
+    for c in chars:
+        if addSpace:
+            d[c] = " {}".format(c) if before else "{} ".format(c)
+        else:
+            k = " {}".format(c) if before else "{} ".format(c)
+            d[k] = c
+    return d
+
+
+def _removeKeys(s: str, sequence: dict):
+    for k in sequence.keys():
+        s = s.replace(str(k), sequence[k])
+    return s
+
+
+def _normalize(txt: str, preferredSeq: dict, removeSeq: dict, toAscii: bool, removeUnprintable: bool, preserveMultispace: bool) -> str:
+    if removeUnprintable:
+        txt = "".join(c for c in txt if c.isprintable())
+    if toAscii:
+        txt = unidecode.unidecode(txt)
+    txt = _removeKeys(txt, preferredSeq)
+    if not preserveMultispace:
+        txt = re.sub(r"\s+", " ", txt)
+    txt = _removeKeys(txt, removeSeq)
+    return txt.strip()
+
+
+def normalizeTxt(
+    txt: str,
+    spaceBefore: str = SPACE_BEFORE,
+    spaceAfter: str = SPACE_AFTER,
+    noSpaceBefore: str = NO_SPACE_BEFORE,
+    noSpaceAfter: str = NO_SPACE_AFTER,
+    toAscii: bool = True,
+    removeUnprintable: bool = True,
+    preserveMultispace: bool = False,
+) -> str:
+    """
+    normalizes string s;\n
+    'β-NS' --> 'b-NS'\n
+    'Some Text(Example)For Display' --> 'Some Text (Example) For Display'
+    """
+    preferredSequences = _createSeq(spaceBefore, True, True)
+    preferredSequences.update(_createSeq(spaceAfter, True, False))
+    removeSequences = _createSeq(noSpaceBefore, False, True)
+    removeSequences.update(_createSeq(noSpaceAfter, False, False))
+    ns = _normalize(txt, preferredSequences, removeSequences, toAscii, removeUnprintable, preserveMultispace)
+    _logger.debug("Text '{}' Normalized To '{}'".format(txt, ns))
+    return ns
+
+
+class TextNormalizer(object):
+    """provides an object that persists the settings and log debug statements if needed"""
+
+    def __init__(
+        self,
+        spaceBefore: str = SPACE_BEFORE,
+        spaceAfter: str = SPACE_AFTER,
+        noSpaceBefore: str = NO_SPACE_BEFORE,
+        noSpaceAfter: str = NO_SPACE_AFTER,
+        toAscii: bool = True,
+        removeUnprintable: bool = True,
+        preserveMultispace: bool = False,
+    ) -> None:
+        self.toAscii = toAscii
+        self.removeUnprintable = removeUnprintable
+        self.preserveMultiSpace = preserveMultispace
+        self.preferredSequences = _createSeq(spaceBefore, True, True)
+        self.preferredSequences.update(_createSeq(spaceAfter, True, False))
+        self.removeSequences = _createSeq(noSpaceBefore, False, True)
+        self.removeSequences.update(_createSeq(noSpaceAfter, False, False))
+
+    def normalize(self, s: str):
+        """
+        normalizes string s;\n
+        'β-NS' --> 'b-NS'\n
+        'Some Text(Example)For Display' --> 'Some Text (Example) For Display'
+        """
+        ns = _normalize(
+            s,
+            self.preferredSequences,
+            self.removeSequences,
+            self.toAscii,
+            self.removeUnprintable,
+            self.preserveMultiSpace,
+        )
+        _logger.debug("Text '{}' Normalized To '{}'".format(s, ns))
+        return ns

kisspy_python-1.0.1.dist-info/METADATA

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: kisspy-python
+Version: 1.0.1
+Summary: Simple Python Scripting Helpers
+Home-page: https://github.com/joemarchionna/kisspy
+Author: Joe Marchionna
+Author-email: joemarchionna@gmail.com
+License: MIT License
+        
+        Copyright (c) Joe Marchionna
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Description-Content-Type: text/markdown
+Requires-Dist: unidecode
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+# kisspy - Simple Python Scripting Helpers
+
+This is a collection of simple helper methods and classes that I have found useful for data processing
+
+## Usage
+
+The package offers simple methods that I found I was reusing frequently.
+
+### Converters
+
+Numeric Converter
+
+````python
+    from kisspy import toNumeric, returnTxt,raiseValExc
+
+    def rtnMsg(*args):
+        return "Can't Convert '{}' To A Number".format(args[0])
+
+    alphaVal = "55"
+    numVal = toNumeric(alphaVal)
+    print(isinstance(numVal, int))
+
+    alphaVal = "88 ft"
+    numVal = toNumeric(alphaVal)
+    print(numVal)
+
+    numVal = toNumeric(alphaVal, onFail=returnTxt)
+    print(numVal)
+
+    numVal = toNumeric(alphaVal, onFail=rtnMsg)
+    print(numVal)
+
+    numVal = toNumeric(alphaVal, onFail=raiseValExc)
+
+>>  True
+>>  None
+>>  88 ft
+>>  Can't Convert '88 ft' To A Number
+>>  Traceback (most recent call last):
+>>  File "C:\Files\code\python\projects\kisspy\examples\converters.py", line 26, in <module>
+>>      numVal = toNumeric(alphaVal, onFail=raiseValExc)
+>>  File "C:\Files\code\python\projects\kisspy\kisspy\converters\numericConverter.py", line 32, in toNumeric
+>>      return onFail(val,verr)
+>>  File "C:\Files\code\python\projects\kisspy\kisspy\converters\numericConverter.py", line 5, in raiseValExc
+>>      raise args[1]
+>>  File "C:\Files\code\python\projects\kisspy\kisspy\converters\numericConverter.py", line 27, in toNumeric
+>>      val = float(val)
+>>  ValueError: could not convert string to float: '88 ft'
+>>  The Value '88 ft' Could Not Be Converted To A Numeric Value
+````
+
+Spreadsheet Converters
+
+````python
+    from kisspy.converters.excelHelpers import fromExcelCol, toExcelCol
+
+    col = "C"
+    print(fromExcelCol(col))
+
+    col = "AF"
+    print(fromExcelCol(col))
+
+    num = 2
+    print(toExcelCol(num))
+
+    num = 33
+    print(toExcelCol(num))
+
+>>  3
+>>  32
+>>  B
+>>  AG
+````
+
+The elements in decorators and metaclasses modules speak for themselves.
+
+There are a number of Python "extensions" that do stuff you would have wanted anyways:
+
+Unique Appending To Lists:
+
+````python
+    from kisspy import appendUnique
+
+    vl = [2, 4, 6, 8]
+    if appendUnique(vl, 4):
+        print("Added 4 Again: {}".format(vl))
+
+    if appendUnique(vl, 10):
+        print("Added 10: {}".format(vl))
+
+>>  Added 10: [2, 4, 6, 8, 10]
+````
+
+Asserting One Record: Returns the one record, with options:
+````python
+    from kisspy import assertOne
+    from kisspy.exceptions import TooManyRecordsException, ZeroRecordsException
+
+
+    def thrwZeroRecordsEx(*args, **kwargs):
+        raise ZeroRecordsException()
+
+
+    vl = [2, 4, 6, 8]
+    print(assertOne([]))
+    print(assertOne([44]))
+
+    try:
+        oneValue = assertOne(vl)
+    except TooManyRecordsException as err:
+        print(err.toStrWithTyp())
+
+    try:
+        print(assertOne([], onZeroRcds=thrwZeroRecordsEx))
+    except ZeroRecordsException as err:
+        print(err.toStrWithTyp())
+
+>>  None
+>>  44
+>>  TooManyRecordsException: 4 Records Returned, 1 Were Expected
+>>  ZeroRecordsException: Zero (0) Records Returned, > 0 Were Expected
+````
+
+Nested Dicts:
+
+````python
+    from kisspy import setValueOfPath, getValueOfPath
+
+    vd = {"animals": {"dog": {"whippet": "fast", "lab": "slower"}}}
+
+    wv = getValueOfPath(vd, keyPath="animals/dog/lab")
+    print(wv)
+
+    cv = getValueOfPath(vd, keyPath="animals/cat/tabby")
+    print(cv)
+
+    setValueOfPath(vd, "animals/dog/golden", "silly")
+    print(vd)
+
+>>  slower
+>>  None
+>>  {'animals': {'dog': {'whippet': 'fast', 'lab': 'slower', 'golden': 'silly'}}}
+````
+
+## Installation
+
+### Using In Projects
+
+Installation:
+
+````bash
+    pip install kisspy-python
+````
+
+### Cloning For Development
+
+<p>Set up a virtual environment. Once an environment is set up, run the command below to:
+
+* validate the environment variable
+* activate the environment (if not already activated) 
+* install all of the necessary packages into the local environment
+
+```bash
+    pip install -U -r requirements/dev.txt
+```
+
+<p>The dev.txt file includes:
+
+* BLACK, a code formatter, see notes at the bottom of this file for details
+
+## Dependancies
+
+This library depends on the following projects:
+
+* unidecode
+
+## Tests
+
+To run tests:
+
+```bash
+    python -m unittest discover -s tests/
+```
+
+## Code Formatting
+
+Code formatting is done using BLACK. BLACK allows almost no customization to how code is formatted with the exception of line length, which has been set to 119 characters.
+
+Use the following to bulk format files:
+
+````bash
+    black . -l 144
+````
+
+## Creating A New Release
+
+Please do the following when making a new release, most are documented above:
+
+1. Run tests
+1. Code format
+1. Be sure to update the change log and _metadata.json with version and notes
+1. git add, commit, and push changes
+1. run the following code to generate a wheel:
+
+````bash
+    python -m build
+````

kisspy_python-1.0.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+kisspy/__init__.py,sha256=1AByCkDjKpxKhk318T0xXUbCrf3lOcaSW2FWu6LEKUs,537
+kisspy/_metadata.json,sha256=AGuqG0M992j9GSzMq5eXJJ_7gnRtFIdnG1s4Z-7dE_Y,535
+kisspy/exceptions.py,sha256=3w0Q_cGgiQnjztuWseeXf-IgC6PIQ_3It7YU_wKG21s,996
+kisspy/converters/__init__.py,sha256=h9Jt5wflyMowJqxXoTZzR6rn_l7osVwzjZSD-vnKSsw,161
+kisspy/converters/excelHelpers.py,sha256=gfSg83RBddY-PaAJsJqYFG9Rv__nvSrJHIQwBOf3t3w,783
+kisspy/converters/numericConverter.py,sha256=c7Mbrumy8-h5V_ItZn9S6RNMmck-AiONVCl6rQQb7DM,1014
+kisspy/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kisspy/decorators/pidFile.py,sha256=05-HuipSi_bwc2K-i_-yAz-idVn6CtMrH3ueOTWmSt0,1070
+kisspy/decorators/singleton.py,sha256=WjXBv8vrPkpgDPIBWcZuwqprd_tCr5-4fL_-mYUv1nE,393
+kisspy/decorators/thrdSafeSync.py,sha256=fQO0qMh3FoZYeCbp9MXrxHWoC-q5nF5Cb4LAuagHFVU,450
+kisspy/metaclasses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kisspy/metaclasses/singleton.py,sha256=J_5WzlumxQEWhGDqFM3slBe1Fqa382HBMOp31045O1w,396
+kisspy/xtdPy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kisspy/xtdPy/dicts.py,sha256=74gL_dLZUMjAhtcVrM_VMUpS1q4SMgCviN7gL4FL-34,2233
+kisspy/xtdPy/json.py,sha256=1PgaUvuSG0g02ojS3t0e0gArcq6QeFRKPKFgg7qctqY,2488
+kisspy/xtdPy/lists.py,sha256=rwxuGbha_Fmkn9eRmP28n-Bb13iHrL8mxw8JmdZ5ggU,3372
+kisspy/xtdPy/dt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kisspy/xtdPy/dt/timeFormatting.py,sha256=SeuImL28ml91mDj2UhiJLIjb-Ul1iiZzkKoqhkgZ1u4,653
+kisspy/xtdPy/paths/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kisspy/xtdPy/paths/_common.py,sha256=TA49EZStx0XOiQAdf3WdDj7MXof-gQsmzY7DtvnpEYY,623
+kisspy/xtdPy/paths/directories.py,sha256=UBaYy_XYfK7c6CLpyOriBo7Y2oa6MgOQ1VV4Bl7SHPk,1561
+kisspy/xtdPy/paths/files.py,sha256=1bF72IrF5B4m0KPmOhS-IXwRfn9oX_ESYXAMe_VtYrg,1570
+kisspy/xtdPy/strings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kisspy/xtdPy/strings/base64data.py,sha256=41je_wjZRt2x70Ksx-vf3lV8CwBOPCqDUtHcEQcP1Z8,734
+kisspy/xtdPy/strings/textExtensions.py,sha256=uG_L5fB3jPKUrGkbcrf-llpp6apH1xXg5SRb38O4Uk8,1319
+kisspy/xtdPy/strings/textNormalizer.py,sha256=X1HWzqBt0-eIY9g1XTezL1eaY30ssl3eJcWIcFQLiI8,3356
+kisspy_python-1.0.1.dist-info/METADATA,sha256=7OBk8QBbiAZMN86B9rBkUKF-ivQaSAUweux7wCbHqgQ,6705
+kisspy_python-1.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+kisspy_python-1.0.1.dist-info/top_level.txt,sha256=MlVmNAYxhXMcmWvxuxk1NMsr-v_ir8Ri51GwxAVJz6s,7
+kisspy_python-1.0.1.dist-info/RECORD,,

kisspy_python-1.0.1.dist-info/WHEEL

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

kisspy_python-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+kisspy