python-ubercode-utils 1.0.10__tar.gz → 2.0.3__tar.gz

python_ubercode_utils-2.0.3/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: python_ubercode_utils
+Version: 2.0.3
+Summary: Core python utilities for all apps
+Home-page: https://github.com/sstacha/python-ubercode-utils
+Author: Steve Stacha
+Author-email: sstacha@gmail.com
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# python-ubercode-utils
+Extracting common python utilities re-used between all projects.  The intent is to have minimal dependencies
+so the library can be used by django settings without circular references.  I also have color logging class for
+jupyter notebooks.  I will have a couple of libraries that will extend this functionality.  Scan the test cases in the 
+tests folder for common use cases.
+
+python-utils-core:
+- basic conversion helper utilities
+- color logging without dependencies
+- manipulating urls and their parameters
+- helper classes to make working with xml and json data easier
+- minimal helper classes to convert database cursor results to dictionaries or tuples

python_ubercode_utils-2.0.3/python_ubercode_utils.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: python-ubercode-utils
+Version: 2.0.3
+Summary: Core python utilities for all apps
+Home-page: https://github.com/sstacha/python-ubercode-utils
+Author: Steve Stacha
+Author-email: sstacha@gmail.com
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# python-ubercode-utils
+Extracting common python utilities re-used between all projects.  The intent is to have minimal dependencies
+so the library can be used by django settings without circular references.  I also have color logging class for
+jupyter notebooks.  I will have a couple of libraries that will extend this functionality.  Scan the test cases in the 
+tests folder for common use cases.
+
+python-utils-core:
+- basic conversion helper utilities
+- color logging without dependencies
+- manipulating urls and their parameters
+- helper classes to make working with xml and json data easier
+- minimal helper classes to convert database cursor results to dictionaries or tuples

{python-ubercode-utils-1.0.10 → python_ubercode_utils-2.0.3}/setup.py

@@ -3,8 +3,8 @@ import setuptools
 with open("README.md", "r") as fh:
     long_description = fh.read()
 
-setuptools.setup(name='python-ubercode-utils',
-      version='1.0.10',
+setuptools.setup(name='python_ubercode_utils',
+      version='2.0.3',
       description='Core python utilities for all apps',
       long_description=long_description,
       long_description_content_type="text/markdown",

{python-ubercode-utils-1.0.10 → python_ubercode_utils-2.0.3}/test/test_data.py

@@ -1,11 +1,11 @@
 import unittest
 from pathlib import Path
 
-from ubercode.utils.data import JSON
-from ubercode.utils.data import XML
+from ubercode.utils.data import JsonData
+from ubercode.utils.data import XmlData
 
 
-class TestJSON(unittest.TestCase):
+class TestJsonData(unittest.TestCase):
 
     # -------- common usages ----------
     def test_JSON(self):
@@ -48,13 +48,11 @@ class TestJSON(unittest.TestCase):
 }
 """
         # test we can construct from a json string
-        json = JSON(json_string=json_string)
-        self.assertEqual(len(json.json_dict['people']), 3)
+        json = JsonData(json_string=json_string)
+        self.assertEqual(len(json.data['people']), 3)
         # test we can construct by chaining and reading file
-        json2 = JSON().from_json_file(str(file_path))
-        self.assertEqual(json.json_dict, json2.json_dict)
-        # test the dict matches the to_dict() result
-        self.assertEqual(json.json_dict, json.to_dict())
+        json2 = JsonData().from_json_file(str(file_path))
+        self.assertEqual(json.data, json2.data)
         # test encoding
         json_string = """
 {
@@ -91,19 +89,19 @@ class TestJSON(unittest.TestCase):
   ]
 }
 """
-        json = JSON(json_string=json_string, encode_ampersands=True)
-        self.assertEqual(len(json.json_dict['people']), 3)
-        first_name = json.to_dict()['people'][0]['firstName']
+        json = JsonData(json_string=json_string, encode_ampersands=True)
+        self.assertEqual(len(json.data['people']), 3)
+        first_name = json.data['people'][0]['firstName']
         self.assertEqual(first_name, "Joe & Baker")
         #  make sure the second name isn't double encoded
-        second_name = json.to_dict()['people'][1]['firstName']
+        second_name = json.data['people'][1]['firstName']
         self.assertEqual(second_name, "James &")
         # test the str function
         result = "{'people': [{'firstName': 'Joe & Baker', 'lastName': 'Jackson', 'gender': 'male', 'age': 28, 'number': '7349282382', 'groups': ['members', 'student']}, {'firstName': 'James &', 'lastName': 'Smith', 'gender': 'male', 'age': 32, 'number': '5678568567', 'groups': ['members', 'professional']}, {'firstName': 'Emily', 'lastName': 'Jones', 'gender': 'female', 'age': 24, 'number': '456754675'}]}"
         self.assertEqual(str(json), result)
 
 
-class TestXML(unittest.TestCase):
+class TestXmlData(unittest.TestCase):
 
     # -------- common usages ----------
     def test_XML(self):
@@ -123,15 +121,15 @@ class TestXML(unittest.TestCase):
 </contacts>
 """
         # test we can construct from an xml string
-        xml = XML(xml_string=xml_string)
+        xml = XmlData(xml_string=xml_string)
         # NOTE: because we used a multiline string we need to strip the extra newlines before and after <contacts>
         self.assertEqual(str(xml), xml_string.strip())
         # normal string doesn't need stripping
         xml_compact_string = "<contacts><contact><name>Buggs Bunny</name></contact><contact><name>Daffy Duck</name></contact></contacts>"
-        xml2 = XML(xml_compact_string)
+        xml2 = XmlData(xml_compact_string)
         self.assertEqual(str(xml2), xml_compact_string)
         # test we can create using the from_xml_string() method chaining
-        xml3 = XML().from_xml_string(xml_compact_string)
+        xml3 = XmlData().from_xml_string(xml_compact_string)
         self.assertEqual(str(xml2), str(xml3))
         # test that method chaining after constructor overrides the value in place
         self.assertNotEqual(str(xml), str(xml2))
@@ -155,7 +153,7 @@ class TestXML(unittest.TestCase):
     </contact>
 </contacts>
 """
-        xml = XML(xml_string=xml_string, encode_ampersands=True)
+        xml = XmlData(xml_string=xml_string, encode_ampersands=True)
         xml_dict = xml.to_dict()
         self.assertEqual(xml_dict['contacts']['contact'][0]['@attr'], '1')
 

{python-ubercode-utils-1.0.10 → python_ubercode_utils-2.0.3}/ubercode/utils/convert.py

@@ -250,3 +250,31 @@ def to_mask(value: str or None) -> str or None:
         _mask += value[-_iqtr:]
     return _mask
 
+def obj_to_str(obj, property_filter_list=None):
+    """
+    Mostly used for debugging.  Very useful to print the properties of an object on a line; condensing reasonably
+
+    :param obj: the object to inspect properties for
+    :param property_filter_list: any property names we want to omit
+    :return: a string containing the outputted properties
+    """
+    attbuf = ""
+    for key, value in vars(obj).items():
+        if property_filter_list and key in property_filter_list:
+            continue
+        if not key.startswith('__'):
+            if len(attbuf) > 0:
+                attbuf += ", "
+            # show the first 50 chars and last 25 chars
+            this_content = str(value)
+            this_content = this_content.replace('\n', ' ').replace('\r', '').strip()
+            if this_content:
+                if len(this_content) > 150:
+                    attbuf += str(key) + ": [" + this_content[0:25] + " ... " + this_content[
+                                                                                len(this_content) - 25:len(
+                                                                                    this_content)] + "]"
+                else:
+                    attbuf += str(key) + ": " + this_content or ""
+            else:
+                attbuf += str(key) + ": " + this_content or ""
+    return "[" + attbuf + "]"

{python-ubercode-utils-1.0.10 → python_ubercode_utils-2.0.3}/ubercode/utils/data.py

@@ -9,12 +9,11 @@ import xml.etree.ElementTree as Etree
 from collections import defaultdict
 
 
-class JSON:
+class JsonData:
     """ simple json class to encapsulate basic json operations """
-    # the base implementation will be dict
-    json_dict = {}
-
     def __init__(self, json_string: str or None = None, encode_ampersands: bool = False):
+        # data is core python objects (list, dict, object, etc) from the core python JSON.loads
+        self.data = None
         self.encode_ampersands = encode_ampersands
         self.from_json_string(json_string)
 
@@ -28,7 +27,7 @@ class JSON:
             if self.encode_ampersands:
                 regex = re.compile(r"&(?!amp;|lt;|gt;)")
                 json_string = regex.sub("&", json_string)
-            self.json_dict = json.loads(json_string)
+            self.data = json.loads(json_string)
         return self
 
     def from_json_file(self, json_file_path: str):
@@ -43,26 +42,18 @@ class JSON:
             if self.encode_ampersands:
                 regex = re.compile(r"&(?!amp;|lt;|gt;)")
                 json_string = regex.sub("&", json_string)
-            self.json_dict = json.loads(json_string)
+            self.data = json.loads(json_string)
         return self
 
-    def to_dict(self) -> dict:
-        """
-        output to dict
-        :return: dict
-        """
-        return self.json_dict
-
     def __str__(self):
-        return str(self.json_dict)
-
+        return str(self.data)
 
-class XML:
-    """ simple xml class to encapsulate basic xml operations """
-    # the base implementation will be Etree from the base python lib
-    xml_tree = None
 
+class XmlData:
+    """ simple xml class to encapsulate basic xml operations using build in python ETree """
     def __init__(self, xml_string: str or None = None, encode_ampersands: bool = False):
+        # data is core python ElementTree object
+        self.data = None
         self.encode_ampersands = encode_ampersands
         self.from_xml_string(xml_string)
 
@@ -76,7 +67,7 @@ class XML:
             if self.encode_ampersands:
                 regex = re.compile(r"&(?!amp;|lt;|gt;)")
                 xml_string = regex.sub("&", xml_string)
-            self.xml_tree = Etree.fromstring(xml_string)
+            self.data = Etree.fromstring(xml_string)
         return self
 
     def from_xml_file(self, xml_file_path: str):
@@ -96,7 +87,7 @@ class XML:
         else:
             tree = Etree.parse(xml_file_path)
             tree = tree.getroot()
-        self.xml_tree = tree
+        self.data = tree
         return self
 
     def to_dict(self) -> dict:
@@ -104,10 +95,10 @@ class XML:
         output to dict
         :return: dict
         """
-        return XML.tree_to_dict(self.xml_tree)
+        return XmlData.tree_to_dict(self.data)
 
     @staticmethod
-    def tree_to_dict(t) -> dict:
+    def tree_to_dict(t: Etree) -> dict:
         """
         Convert an etree structure to a dictionary of values
         :param t: etree instance
@@ -117,7 +108,7 @@ class XML:
         children = list(t)
         if children:
             dd = defaultdict(list)
-            for dc in map(XML.tree_to_dict, children):
+            for dc in map(XmlData.tree_to_dict, children):
                 for k, v in dc.items():
                     dd[k].append(v)
             d = {t.tag: {k: v[0] if len(v) == 1 else v for k, v in dd.items()}}
@@ -133,6 +124,6 @@ class XML:
         return d
 
     def __str__(self):
-        if self.xml_tree:
-            return Etree.tostring(self.xml_tree, encoding='unicode')
+        if self.data:
+            return Etree.tostring(self.data, encoding='unicode')
         return ""

{python-ubercode-utils-1.0.10 → python_ubercode_utils-2.0.3}/ubercode/utils/dataframe.py

@@ -1,7 +1,26 @@
 """ common utilities for working with dataframes"""
 from typing import Any
 from . import logging
+from datetime import datetime
 
+default_date_formats = {
+    'date': '%Y-%m-%d',
+    'datetime': '%Y-%m-%d %H:%M:%S',
+    'datetimemilli': '%Y-%m-%d %H:%M:%S.%f'
+}
+
+def to_date_str(date_string: str or None, date_col: str, date_field_map: dict, date_formats: dict) -> str or None:
+    if date_string == 'None' or date_string == 'NaT' or not date_string:
+        return None
+    if '.' in date_string:
+        dt = datetime.strptime(date_string, date_formats['datetimemilli'])
+    elif ':' in date_string:
+        dt = datetime.strptime(date_string, date_formats['datetime'])
+    else:
+        dt = datetime.strptime(date_string, date_formats['date'])
+    if not dt:
+        return None
+    return dt.strftime(date_formats[date_field_map[date_col]])
 
 # extend the logging to include log.dataframe()
 # NOTE: making dataframe type Any, so we don't have to include pandas but intended use is dataframe

{python-ubercode-utils-1.0.10 → python_ubercode_utils-2.0.3}/ubercode/utils/environment.py

@@ -6,6 +6,7 @@ import os
 import time
 from datetime import datetime
 from typing import Any, Tuple
+from pathlib import Path
 from ubercode.utils.logging import ColorLogger
 from ubercode.utils import convert
 
@@ -223,3 +224,61 @@ class Environment:
                         self._logger.warn(
                             f"{db_parts[0]}[{db_parts[1]}][{db_parts[2]}] has a database or property naming issue!")
         return db_dict
+
+class FauxApp:
+    def __init__(self, logger: ColorLogger = None, notebook_path: Path = Path(), default_dict: dict = None) -> None:
+        self._logger = logger if logger else _utils_settings_logger
+        self.notebook_path = notebook_path.resolve()
+        self.app_path = os.path.dirname(self.notebook_path)
+        self.project_path = os.path.dirname(self.app_path)
+        self.instance_path = os.path.join(self.project_path, 'instance')
+        self.config = default_dict or dict(
+            SECRET_KEY = 'localmachine',
+            LOG_LEVEL = 'DEBUG',
+            DEBUG = True,
+            APP_DIR = self.app_path,
+            PROJECT_DIR = self.project_path,
+            DATABASE_DEBUG = False,
+            SA_URL_APP = f'sqlite+pysqlite:///{os.path.join(self.instance_path, "nbsync.sqlite3")}',
+            SA_URL_SRC_LOCAL = f'sqlite+pysqlite:///{os.path.join(self.instance_path, "src.sqlite3")}',
+            SA_URL_DST_LOCAL = f'sqlite+pysqlite:///{os.path.join(self.instance_path, "dst.sqlite3")}',
+        )
+
+    def from_mapping(self, mapping: dict) -> None:
+        self.config = self.config | mapping
+
+    def from_pyfile(self, config_file: str = '~/conf/nbsync.cfg') -> None:
+        # read the config file into dict if exists then merge
+        abs_cfg = os.path.expanduser(config_file)
+        try:
+            with open(abs_cfg, 'r') as fp:
+                for line in fp:
+                    line = line.strip()
+                    if line.startswith('#') or not line:
+                        continue
+                    # Split only on the first '=' to allow '=' in the value
+                    try:
+                        key, val = line.split('=', 1)
+                        self.config[key.strip().strip("'").strip('"')] = val.strip().strip("'").strip('"')
+                    except ValueError:
+                        # Handle lines that might not have an '='
+                        continue
+        except FileNotFoundError:
+            self._logger.debug(f'[{config_file}] does not exist')
+
+    def from_prefixed_env(self, prefix: str = 'UC'):
+        # read environment variables with the given prefix and merge into config
+        prefix_len = len(prefix) + 1  # +1 for the underscore
+        for key, value in os.environ.items():
+            if key.startswith(f'{prefix}_'):
+                config_key = key[prefix_len:]  # remove the prefix and underscore
+                self.config[config_key] = value
+                # lastly, attempt to convert 'true'/'false' to boolean
+                if value.lower() == 'true':
+                    self.config[config_key] = True
+                elif value.lower() == 'false':
+                    self.config[config_key] = False
+
+    def __repr__(self):
+        return convert.obj_to_str(self)
+

{python-ubercode-utils-1.0.10 → python_ubercode_utils-2.0.3}/ubercode/utils/logging.py

@@ -183,7 +183,7 @@ class ColorLogger:
             c_msg = str(msg)
             if self.color_output and color:
                 c_msg = color + c_msg + TermColor.ENDC
-            if msg == self.repeat_msg:
+            if str(msg) == self.repeat_msg:
                 # the first time we start repeating track the indent level
                 if not self.repeat_cnt:
                     if indent is not None:

python-ubercode-utils-1.0.10/PKG-INFO

@@ -1,29 +0,0 @@
-Metadata-Version: 2.1
-Name: python-ubercode-utils
-Version: 1.0.10
-Summary: Core python utilities for all apps
-Home-page: https://github.com/sstacha/python-ubercode-utils
-Author: Steve Stacha
-Author-email: sstacha@gmail.com
-License: MIT
-Description: # python-ubercode-utils
-        Extracting common python utilities re-used between all projects.  The intent is to have minimal dependencies
-        so the library can be used by django settings without circular references.  I also have color logging class for
-        jupyter notebooks.  I will have a couple of libraries that will extend this functionality.  Scan the test cases in the 
-        tests folder for common use cases.
-        
-        python-utils-core:
-        - basic conversion helper utilities
-        - color logging without dependencies
-        - manipulating urls and their parameters
-        - helper classes to make working with xml and json data easier
-        - minimal helper classes to convert database cursor results to dictionaries or tuples
-        
-Platform: UNKNOWN
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Utilities
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown

python-ubercode-utils-1.0.10/python_ubercode_utils.egg-info/PKG-INFO

@@ -1,29 +0,0 @@
-Metadata-Version: 2.1
-Name: python-ubercode-utils
-Version: 1.0.10
-Summary: Core python utilities for all apps
-Home-page: https://github.com/sstacha/python-ubercode-utils
-Author: Steve Stacha
-Author-email: sstacha@gmail.com
-License: MIT
-Description: # python-ubercode-utils
-        Extracting common python utilities re-used between all projects.  The intent is to have minimal dependencies
-        so the library can be used by django settings without circular references.  I also have color logging class for
-        jupyter notebooks.  I will have a couple of libraries that will extend this functionality.  Scan the test cases in the 
-        tests folder for common use cases.
-        
-        python-utils-core:
-        - basic conversion helper utilities
-        - color logging without dependencies
-        - manipulating urls and their parameters
-        - helper classes to make working with xml and json data easier
-        - minimal helper classes to convert database cursor results to dictionaries or tuples
-        
-Platform: UNKNOWN
-Classifier: Development Status :: 3 - Alpha
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Utilities
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown