kisspy-python 1.0.1__tar.gz → 1.2.0__tar.gz

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kisspy-python
-Version: 1.0.1
+Version: 1.2.0
 Summary: Simple Python Scripting Helpers
 Home-page: https://github.com/joemarchionna/kisspy
 Author: Joe Marchionna

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/changes.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 none
 
+## [1.2.0] - 2026 05 07
+### Added
+- methodParameter decorators
+
+## [1.1.0] - 2026 04 07
+### Changed
+- Doc Strings 
+- minor edits to methods
+
 ## [1.0.0] - 2026 03 18
 ### Added
 - Release Published

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/kisspy/_metadata.json

@@ -1,7 +1,7 @@
 
 {
     "name": "kisspy-python",
-    "version": "1.0.1",
+    "version": "1.2.0",
     "author": "Joe Marchionna",
     "author_email": "joemarchionna@gmail.com",
     "description": "Simple Python Scripting Helpers",

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/kisspy/converters/excelHelpers.py

@@ -13,7 +13,15 @@ def _divmod_excel(n):
 
 
 def toExcelCol(columnNum: int) -> str:
-    """converts a 1-based column number to Excel column name, ie: 27 -> AA"""
+    """
+    converts a 1-based column number to Excel-ish column name, ie: 1 -> A; 27 -> AA
+
+    Args:
+        columnNum (int): the column number
+
+    Returns:
+        str: the column name
+    """
     chars = []
     while columnNum > 0:
         columnNum, d = _divmod_excel(columnNum)
@@ -22,5 +30,13 @@ def toExcelCol(columnNum: int) -> str:
 
 
 def fromExcelCol(columnName: str) -> int:
-    """converts an Excel column name to a 1-based integer, ie: AA -> 27"""
+    """
+    converts an Excel column name to a 1-based integer, ie: A -> 1; AA -> 27
+
+    Args:
+        columnName (str): the column name
+
+    Returns:
+        int: the column number
+    """
     return reduce(lambda r, x: r * 26 + x + 1, map(string.ascii_uppercase.index, columnName), 0)

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/kisspy/converters/numericConverter.py

@@ -12,15 +12,21 @@ def returnNone(*args, **kwargs) -> None:
 
 def returnTxt(*args, **kwargs) -> None:
     """returns the first argument, does nothing else"""
-    return args[0]
+    if args:
+        return args[0]
+    return ""
 
 
 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
+    returns a float or int, by converting the provided val to a float and if possible, an int
+
+    Args:
+        val (_type_): the value to attempt to convert
+        onFail (callable, optional): on error or failure, this is called with the value as the first arg / parameter and the exception as the second parameter. Defaults to returnNone
+
+    Returns:
+        float | int | None: resulting value
     """
     try:
         if isinstance(val, str):
@@ -29,4 +35,6 @@ def toNumeric(val, onFail=returnNone) -> float | int | None:
             return int(val)
         return val
     except ValueError as verr:
+        if not onFail:
+            return None
         return onFail(val, verr)

kisspy_python-1.2.0/kisspy/decorators/methodParameters.py

@@ -0,0 +1,97 @@
+import functools
+import inspect
+
+
+def _raiseValueErrorIfErrors(errors: list[str], frmt: str):
+    if not errors:
+        return
+    raise ValueError(frmt.format(", ".join(errors)))
+
+
+def parametersNotNone(paramNames: list[str]):
+    """
+    validates that the parameters that are listed are not literally 'None'
+
+    Args:
+        paramNames (list[str]): the decorated function parameter names to validate
+
+    Raises:
+        ValueError
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            sig = inspect.signature(func)
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+            errors = []
+            for pn in paramNames:
+                if pn in bound.arguments:
+                    val = bound.arguments[pn]
+                    if val is None:
+                        errors.append(pn)
+            _raiseValueErrorIfErrors(errors, "Parameter(s) '{}' Cannot Be 'None'")
+            return func(*bound.args, **bound.kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def parametersHaveTruthyValue(paramNames: list[str]):
+    """
+    validates that the parameters that are listed all have 'truthy' values
+
+    Args:
+        paramNames (list[str]): the decorated function parameter names to validate
+
+    Raises:
+        ValueError
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            sig = inspect.signature(func)
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+            errors = []
+            for pn in paramNames:
+                if pn in bound.arguments:
+                    val = bound.arguments[pn]
+                    if not val:
+                        errors.append(pn)
+            _raiseValueErrorIfErrors(errors, "Parameter(s) '{}' Are Not A Truthy Value")
+            return func(*bound.args, **bound.kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def parameterLimit(paramName: str, lo: float | int, hi: float | int):
+    """
+    validates that the listed parameter's value is within the hi and lo value specified
+    and corrects the value keeping it within the range specified
+
+    Args:
+        paramName (str): the decorated function parameter name to validate
+        lo (float | int): lower value limit
+        hi (float | int): upper value limit
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            sig = inspect.signature(func)
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+            if paramName in bound.arguments:
+                val = bound.arguments[paramName]
+                bound.arguments[paramName] = max(lo, min(hi, val))
+            return func(*bound.args, **bound.kwargs)
+
+        return wrapper
+
+    return decorator

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/kisspy/decorators/singleton.py

@@ -1,12 +1,16 @@
 def singleton(_class):
     """
-    class decorator to create a single instance of a class;\n
-    usage:\n
+    class decorator to create a single instance of a class
 
-    @singleton\n
-    class MyClass(<baseClass>):\n
-        pass
+    Args:
+        _class (_type_): the class to decorate
 
+    Example:
+        ````python
+        @singleton
+        class MyClass(<baseClass>):
+            pass
+        ````
     """
     _instances = {}
 

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/kisspy/decorators/thrdSafeSync.py

@@ -3,13 +3,18 @@ import threading
 
 def thrdSafeSync(func):
     """
-    decorator that makes the function thread safe\n
-    example:\n
-    ```python
-    @thrdSafeSync
-    def oneAtATime():
-        file IO process...
-    ```
+    decorator that makes the function thread safe
+
+    Args:
+        func (_type_): the method to decorate
+
+    Example:
+
+        ````python
+        @thrdSafeSync
+        def oneAtATime():
+            file IO process...
+        ````
     """
     lock = threading.Lock()  # A lock for this specific function
 

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/kisspy/exceptions.py

@@ -11,6 +11,9 @@ class TooManyRecordsException(KisspyException):
     MSG_FORMAT = "{} {} Returned, {} Were Expected"
 
     def __init__(self, *args: object, numberRecords: int = None, recordType: str = "Records", numberExpected: int = 1) -> None:
+        self.numberRecords = numberRecords
+        self.numberExpected = numberExpected
+        self.recordType = recordType
         if numberRecords and recordType:
             msg = TooManyRecordsException.MSG_FORMAT.format(numberRecords, recordType, numberExpected)
             super().__init__(msg, *args)
@@ -22,6 +25,7 @@ class ZeroRecordsException(KisspyException):
     MSG_FORMAT = "Zero (0) {} Returned, > 0 Were Expected"
 
     def __init__(self, *args, recordType: str = "Records"):
+        self.recordType = recordType
         if args:
             super().__init__(*args)
         else:

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/kisspy/metaclasses/singleton.py

@@ -1,11 +1,12 @@
 class Singleton(type):
     """
-    meta-class to create a single instance of a class;\n
-    usage:\n
-
-    class MyClass(<baseClass>, metaclass=Singleton):\n
-        pass
+    meta-class to create a single instance of a class
 
+    Example:
+        ````python
+        class MyClass(<baseClass>, metaclass=Singleton):\n
+            pass
+        ````
     """
 
     _instances = {}

kisspy_python-1.2.0/kisspy/xtdPy/dicts.py

@@ -0,0 +1,90 @@
+import json
+
+
+def getValueOfPath(data: dict, keyPath: str, defaultValue=None):
+    """
+    returns the value at the key path provided of a multi-level dict
+
+    Args:
+        data (dict): the dict to evaluate, ie: {'animals':{'dogs':{'whippet':'fast'}}}
+        keyPath (str): key 'path' to work down using '/' as separators, ie: 'animals/dogs/whippet' returns 'fast'
+        defaultValue (_type_, optional): default value returned if the path is not found. Defaults to None
+
+    Returns:
+        _type_: value of the final key of the path
+    """
+    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
+
+    Args:
+        data (dict): the dict to evaluate
+        keyPath (str): key 'path' to work down using '/' as separators
+        value (_type_): value to set the last key of the path to
+        createTree (bool, optional): if True, it creates a dict if any key in the path does not exist, otherwise does not set the value and exits. Defaults to True
+
+    Returns:
+        bool: True if the value was set, False if it did not set the value
+    """
+    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: dict | list) -> dict | list:
+    """
+    returns a true deep copy of the original data object by serializing to JSON and back again
+
+    Args:
+        data (dict|list): JSON-isable object
+
+    Returns:
+        dict|list: copy of the input data
+    """
+    jStr = json.dumps(data)
+    return json.loads(jStr)
+
+
+def addToDictIfExists(destination: dict, fieldName: str, fieldValue, normalizeTxtTo: str = None) -> bool:
+    """
+    adds the fieldvalue assigned to the fieldname key in the destination dictionary, if the fieldvalue is truthy
+
+    Args:
+        destination (dict): the dict to add the field to
+        fieldName (str): the field or key name
+        fieldValue (_type_): the field or key value
+        normalizeTxtTo (str, optional): name of the method on the object to call to normalize, ie: 'lower'. Defaults to None
+
+    Returns:
+        bool: True if the value was set, False if it did not set the value
+    """
+    if not fieldValue:
+        return False
+    if isinstance(fieldValue, str) and normalizeTxtTo:
+        mthd = getattr(fieldValue, normalizeTxtTo)
+        if callable(mthd):
+            fieldValue = mthd()
+    destination[fieldName] = fieldValue
+    return True

kisspy_python-1.2.0/kisspy/xtdPy/dt/timeFormatting.py

@@ -0,0 +1,26 @@
+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: str = None, suffix: str = None, frmt: str = SORTABLE_DT_FRMT) -> str:
+    """
+    returns the date and time as a sortable string separated by a period ie: 'YYYYmmdd.HHMMSS' or the format provided
+
+    Args:
+        prefix (str, optional): text added before sortable date/time. Defaults to None
+        suffix (str, optional): text added before sortable date/time. Defaults to None
+        frmt (str, optional): datatime output format. Defaults to SORTABLE_DT_FRMT
+
+    Returns:
+        str: the current datetime formatted as specified
+    """
+    val = ""
+    if prefix:
+        val = prefix
+    val = val + datetime.datetime.now().strftime(frmt)
+    if suffix:
+        val = val + suffix
+    return val

kisspy_python-1.2.0/kisspy/xtdPy/lists.py

@@ -0,0 +1,84 @@
+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
+
+    Args:
+        elements (list[dict]): original list of objects
+        key (str): key to evaluate value of when binning objects
+        noKeyOrValue (str, optional): if set will bin records with missing or null values together. to not bin missing or null values set to 'None'. Defaults to NO_VALUE
+
+    Returns:
+        list[list[dict]]: binned records based on value
+
+    Example:
+    ````python
+        i = [{'a':1}, {'a':2}, {'a':2}, {'a':1}, {'a':4}, {'a':1}, {'a':5} ]
+        z = binRecordsOnKey(i, 'a')
+        z = [
+                [{'a':1}, {'a':1}, {'a':1}],
+                [{'a':2}, {'a':2}],
+                [{'a':4}],
+                [{'a':5}]
+            ]
+    ````
+    """
+    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
+
+    Args:
+        lst (list): the list to possibly append the value to
+        obj (_type_): the object to append to the list
+
+    Returns:
+        bool: 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
+    NOTE: the callables are passed the records list as an arg
+
+    Args:
+        records (list): the list to be evaluated
+        onZeroRcds (callable, optional): if the list is empty or None, returns the result of the callable if provided. Defaults to None
+        onMultiRcds (callable, optional): if the length of the list is greater than one, returns the result of the callable if provided. Defaults to raising a TooManyRecordsException
+
+    Returns:
+        dict | list: single record object or None
+    """
+    if not records:
+        if onZeroRcds:
+            return onZeroRcds(records)
+        return None
+    if len(records) > 1:
+        if onMultiRcds:
+            return onMultiRcds(records)
+        return records
+    return records[0]

kisspy_python-1.2.0/kisspy/xtdPy/paths/directories.py

@@ -0,0 +1,68 @@
+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]:
+    """
+    splits the filename to the path and basename - same as os.path.split except converts to forward slashes and endings if specified
+
+    Args:
+        filename (str): path to split
+        convertToFwdSlsh (bool, optional): converts any backslash to forward slash if True. Defaults to True
+        endInSeparator (bool, optional): ends the directory path with a slash if specified. Defaults to True
+
+    Returns:
+        Tuple[str, str]: directory path, basename
+    """
+    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
+
+    Args:
+        fqFilename (str): fully-qualified filename with path - set to None if providing just a directory parameter
+        directory (str, optional): directory to create. Defaults to None
+        convertToFwdSlsh (bool, optional): converts any backslash to forward slash if True. Defaults to True
+        endInSeparator (bool, optional): ends the directory path with a slash if specified. Defaults to True
+
+    Returns:
+        str: 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
+
+    Args:
+        path (str): _description_
+        expandChar (str, optional): representative char for the user directory. Defaults to "~"
+        convertToFwdSlsh (bool, optional): converts any backslash to forward slash if True. Defaults to True
+        endInSeparator (bool, optional): ends the directory path with a slash if specified. Defaults to False
+
+    Returns:
+        str: path
+    """
+    if not path or not path.startswith(expandChar):
+        return path
+    homeDir = frmtPath(str(pathlib.Path.home()), convertToFwdSlsh, endInSeparator)
+    return path.replace(expandChar, homeDir)

kisspy_python-1.2.0/kisspy/xtdPy/paths/files.py

@@ -0,0 +1,72 @@
+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: str) -> datetime.datetime:
+    """
+    returns a datetime object for the last modified datetime of the file specified
+
+    Args:
+        fqFilename (str): the path to the file
+
+    Returns:
+        datetime.datetime: last modified datetime
+    """
+    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, directories: list[str]) -> str:
+    """
+    searches for a file in the locations provided and returns the file path;\n
+    will expand to the user's home folder if a path starts with ~
+
+    Args:
+        filename (str): the file name to search for
+        directories (list[str]): a list of possible locations, ie directories
+
+    Returns:
+        str: the file path to the existing (found) file
+    """
+    for fn in [_getFn(x, filename) for x in directories]:
+        _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: dict | list = None) -> Tuple[str, dict]:
+    """
+    searches for a file in the locations provided; if a file is found, it \n
+    loads the file with json and returns the file's content;\n
+    will expand to the user's home folder if a path starts with ~
+
+    Args:
+        filename (str): the file name to search for
+        directories (list[str]): a list of possible locations, ie directories
+        defaultData (dict|list, optional): default data to return if no file is present. Defaults to None
+
+    Returns:
+        Tuple[str, dict]: a tuple: found file name and file content
+    """
+    fn = searchForFile(filename, directories)
+    if fn:
+        _logger.debug("Found File '{}'".format(fn))
+        return fn, loadData(fn, defaultData)
+    return None, defaultData

kisspy_python-1.2.0/kisspy/xtdPy/strings/base64data.py

@@ -0,0 +1,54 @@
+import base64
+
+
+def fromFile(filename: str) -> str:
+    """
+    returns a string representing the file contents in Base64
+
+    Args:
+        filename (str): the filename of the file to evaluate / convert
+
+    Returns:
+        str: the Base64 representation of the file contents
+    """
+    with open(filename, "rb") as image_file:
+        data = base64.b64encode(image_file.read()).decode("utf-8")
+    return data
+
+
+def fromBytes(bytes: bytes) -> str:
+    """
+    returns a string representing the bytes in Base64
+
+    Args:
+        bytes (bytes): bytes from file or stream
+
+    Returns:
+        str: the Base64 representation of the bytes
+    """
+    return base64.b64encode(bytes).decode("utf-8")
+
+
+def toBytes(base64str: str) -> bytes:
+    """
+    writes Base64 string back to original binary encoding
+
+    Args:
+        base64str (str): the Base64 encoded string
+
+    Returns:
+        bytes: binary encoded bytes
+    """
+    return base64.b64decode(base64str)
+
+
+def toFile(filename: str, base64str: str):
+    """
+    writes Base64 string back to original binary encoded file
+
+    Args:
+        filename (str): the filename to save the bytes to
+        base64str (str): the original Base64 encoded string
+    """
+    with open(filename, "wb") as writer:
+        writer.write(base64.b64decode(base64str))

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/kisspy_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kisspy-python
-Version: 1.0.1
+Version: 1.2.0
 Summary: Simple Python Scripting Helpers
 Home-page: https://github.com/joemarchionna/kisspy
 Author: Joe Marchionna

{kisspy_python-1.0.1 → kisspy_python-1.2.0}/kisspy_python.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ kisspy/converters/__init__.py
 kisspy/converters/excelHelpers.py
 kisspy/converters/numericConverter.py
 kisspy/decorators/__init__.py
+kisspy/decorators/methodParameters.py
 kisspy/decorators/pidFile.py
 kisspy/decorators/singleton.py
 kisspy/decorators/thrdSafeSync.py

kisspy_python-1.0.1/kisspy/xtdPy/dicts.py

@@ -1,63 +0,0 @@
-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_python-1.0.1/kisspy/xtdPy/dt/timeFormatting.py

@@ -1,21 +0,0 @@
-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_python-1.0.1/kisspy/xtdPy/lists.py

@@ -1,95 +0,0 @@
-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_python-1.0.1/kisspy/xtdPy/paths/directories.py

@@ -1,43 +0,0 @@
-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_python-1.0.1/kisspy/xtdPy/paths/files.py

@@ -1,48 +0,0 @@
-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_python-1.0.1/kisspy/xtdPy/strings/base64data.py

@@ -1,32 +0,0 @@
-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))