python-ubercode-utils 2.0.0__tar.gz → 2.0.4__tar.gz

python_ubercode_utils-2.0.4/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: python_ubercode_utils
+Version: 2.0.4
+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.4/python_ubercode_utils.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: python-ubercode-utils
+Version: 2.0.4
+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.0 → python_ubercode_utils-2.0.4}/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='2.0.0',
+setuptools.setup(name='python_ubercode_utils',
+      version='2.0.4',
       description='Core python utilities for all apps',
       long_description=long_description,
       long_description_content_type="text/markdown",

{python-ubercode-utils-2.0.0 → python_ubercode_utils-2.0.4}/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,10 +48,10 @@ class TestJSON(unittest.TestCase):
 }
 """
         # test we can construct from a json string
-        json = JSON(json_string=json_string)
+        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))
+        json2 = JsonData().from_json_file(str(file_path))
         self.assertEqual(json.data, json2.data)
         # test encoding
         json_string = """
@@ -89,7 +89,7 @@ class TestJSON(unittest.TestCase):
   ]
 }
 """
-        json = JSON(json_string=json_string, encode_ampersands=True)
+        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")
@@ -101,7 +101,7 @@ class TestJSON(unittest.TestCase):
         self.assertEqual(str(json), result)
 
 
-class TestXML(unittest.TestCase):
+class TestXmlData(unittest.TestCase):
 
     # -------- common usages ----------
     def test_XML(self):
@@ -121,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))
@@ -153,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-2.0.0 → python_ubercode_utils-2.0.4}/test/test_environment.py

@@ -80,7 +80,9 @@ class TestEnvironment(unittest.TestCase):
         }
         environment = Environment(environment_variable_map=os_vars)
         # test we can override just the database file name
-        DATABASES = environment.override_database_variables(DATABASES)
+        with redirect_stdout(StringIO()) as sout:
+            DATABASES = environment.override_database_variables(DATABASES)
+        print(f"override_vars password log output \n{sout.getvalue()}")
         self.assertEqual(DATABASES['default']['NAME'], BASE_DIR / "sqlite.db")
         # test we can take the default sqlite database and change it to a full mysql connection using env vars
         os_vars = {
@@ -95,8 +97,7 @@ class TestEnvironment(unittest.TestCase):
         # test we can override the default sqllite for dev laptops with a full mysql connection on a deployed server
         with redirect_stdout(StringIO()) as sout:
             DATABASES = environment.override_database_variables(DATABASES)
-        log_output = sout.getvalue()
-        print(log_output)
+        print(f"override_vars log output \n{sout.getvalue()}")
         self.assertEqual(DATABASES['default']['ENGINE'], 'django.db.backends.mysql')
         self.assertEqual(DATABASES['default']['HOST'], 'testdb.example.org')
         self.assertEqual(DATABASES['default']['NAME'], 'test')
@@ -104,11 +105,63 @@ class TestEnvironment(unittest.TestCase):
         self.assertEqual(DATABASES['default']['PASSWORD'], 'Test_insecure_password')
         self.assertEqual(DATABASES['default']['PORT'], 3306)
         # test our password is encoded when logged
-        self.assertTrue("Test_insecure_password" not in log_output)
-        self.assertTrue("Test_************sword" in log_output)
+        self.assertTrue("Test_insecure_password" not in sout.getvalue())
+        self.assertTrue("Test_************sword" in sout.getvalue())
         # test a None still works for initialization
         self.assertIsNotNone(Environment())
 
+    def test_override_database_urls(self):
+        # we will start with the default dict for a new django install
+        BASE_DIR = Path(__file__).resolve().parent
+        DATABASES = {
+            'default': {
+                'ENGINE': 'django.db.backends.sqlite3',
+                'NAME': BASE_DIR / 'db.sqlite3',
+            }
+        }
+        db_override = BASE_DIR / "sqlite.db"
+        os_vars = {
+            "DJ_URL_default": f"://@/{db_override}",
+#            "DATABASES__default__NAME": BASE_DIR / "sqlite.db",
+            "TEST_DATE": "2023-02-21 08:30:00",
+            "TEST_INT": "1",
+            "PW": "abc1234def",
+            "TEST_STRING": "abc1234def"
+        }
+        environment = Environment(environment_variable_map=os_vars)
+        # test we can override just the database file name
+        with redirect_stdout(StringIO()) as djurl_out:
+            DATABASES = environment.override_database_urls(DATABASES)
+        print(f"djurl password log output: \n{djurl_out.getvalue()}")
+
+        self.assertEqual(DATABASES['default']['NAME'], str(db_override))
+        # test we can take the default sqlite database and change it to a full mysql connection using env vars
+        # os_vars = {
+        #     'DATABASES__default__ENGINE': 'django.db.backends.mysql',
+        #     'DATABASES__default__HOST': 'testdb.example.org',
+        #     'DATABASES__default__NAME': 'test',
+        #     'DATABASES__default__USER': 'testuser',
+        #     'DATABASES__default__PASSWORD': 'Test_insecure_password',
+        #     'DATABASES__default__PORT': 3306,
+        # }
+        os_vars = {
+            'DJ_URL_default': 'django.db.backends.mysql://testuser:Test_insecure_password@testdb.example.org:3306/test'
+        }
+        environment = Environment(environment_variable_map=os_vars)
+        # test we can override the default sqllite for dev laptops with a full mysql connection on a deployed server
+        with redirect_stdout(StringIO()) as djurl_out:
+            DATABASES = environment.override_database_urls(DATABASES)
+        print(f"djurl full log output \n{djurl_out.getvalue()}")
+        self.assertEqual(DATABASES['default']['ENGINE'], 'django.db.backends.mysql')
+        self.assertEqual(DATABASES['default']['HOST'], 'testdb.example.org')
+        self.assertEqual(DATABASES['default']['NAME'], 'test')
+        self.assertEqual(DATABASES['default']['USER'], 'testuser')
+        self.assertEqual(DATABASES['default']['PASSWORD'], 'Test_insecure_password')
+        self.assertEqual(DATABASES['default']['PORT'], 3306)
+        # test our password is encoded when logged
+        self.assertTrue("Test_insecure_password" not in djurl_out.getvalue())
+
+
     def test_timer(self):
         timer = Timer().start()
         time.sleep(3)

{python-ubercode-utils-2.0.0 → python_ubercode_utils-2.0.4}/test/test_urls.py

@@ -4,6 +4,7 @@ from io import StringIO
 
 from ubercode.utils.urls import ParsedUrl
 from ubercode.utils.urls import ParsedQueryString
+from ubercode.utils.urls import DjUrl
 
 
 class TestUrls(unittest.TestCase):
@@ -49,7 +50,46 @@ class TestUrls(unittest.TestCase):
         parsed_url = ParsedUrl(test_uri, default_scheme='http', default_netloc='localhost:8000', default_filepath='/booger/')
         self.assertEqual("tel", str(parsed_url.scheme))
         self.assertEqual(test_uri, parsed_url.url)
-
+        # test that a full django database url parses to the individual parts correctly
+        dj_db_url = DjUrl('django.db.backends.mysql://scott:tiger@localhost:1366/test')
+        self.assertEqual(dj_db_url.engine,'django.db.backends.mysql')
+        self.assertEqual(dj_db_url.host, 'localhost')
+        self.assertEqual(dj_db_url.user, 'scott')
+        self.assertEqual(dj_db_url.password, 'tiger')
+        self.assertEqual(dj_db_url.port, 1366)
+        self.assertEqual(dj_db_url.name, 'test')
+        # test that str masks password
+        self.assertNotIn(str(dj_db_url), 'tiger')
+        # test that a missing one is falsy so it doesn't get overridden at startup
+        dj_db_url = DjUrl('://localhost/test')
+        self.assertFalse(dj_db_url.engine)
+        self.assertFalse(dj_db_url.user)
+        self.assertFalse(dj_db_url.password)
+        self.assertFalse(dj_db_url.port)
+        self.assertTrue(dj_db_url.host)
+        self.assertTrue(dj_db_url.name)
+        # test that an empty url doesn't break and returns false for everything
+        dj_db_url = DjUrl('')
+        self.assertFalse(dj_db_url.engine)
+        self.assertFalse(dj_db_url.user)
+        self.assertFalse(dj_db_url.password)
+        self.assertFalse(dj_db_url.port)
+        self.assertFalse(dj_db_url.host)
+        self.assertFalse(dj_db_url.name)
+        # test that str returns an encoded version that may include separators but can be re-initted correctly
+        dj_db_url = DjUrl(str(dj_db_url))
+        self.assertFalse(dj_db_url.engine)
+        self.assertFalse(dj_db_url.user)
+        self.assertFalse(dj_db_url.password)
+        self.assertFalse(dj_db_url.port)
+        self.assertFalse(dj_db_url.host)
+        self.assertFalse(dj_db_url.name)
+        # test that just password works since this is most common
+        dj_db_url = DjUrl(':asdf:!/stuff #')
+        self.assertEqual(dj_db_url.password, 'asdf:!/stuff #')
+        # test encoded @ for password since that could be needed
+        dj_db_url = DjUrl(':asfcasdf23%401:/!?--atencoded')
+        self.assertEqual(dj_db_url.password, 'asfcasdf23@1:/!')
 
     # --- basic retrieval
     # -------------------

{python-ubercode-utils-2.0.0 → python_ubercode_utils-2.0.4}/ubercode/utils/convert.py

@@ -13,7 +13,7 @@ FALSE_VALUES = [None, False, 0, "0", "n", "f", "false", "no", "off"]
 
 
 # -------- helper utilities ----------
-def strip(value: str or None, strip_chars: str = None, left: bool = True, right: bool = True) -> str or None:
+def strip(value: str | None, strip_chars: str = None, left: bool = True, right: bool = True) -> str | None:
     """
     return stripped value if possible or original value
     :param value: str value to be stripped
@@ -94,7 +94,7 @@ def to_bool(value) -> bool:
     return bool(value)
 
 
-def is_true(value: int or bool or str) -> bool:
+def is_true(value: int | bool | str) -> bool:
     """
     Convert <value> to a True boolean value.  Useful when you want to convert a passed parameter to True if it matches
     one of the defined TRUE_VALUES above; otherwise False.
@@ -121,7 +121,7 @@ def to_js_bool(bool_value: bool) -> str:
     return "false"
 
 
-def to_int(value, default: int = 0, none_to_default: bool = True, suppress_warnings: bool = True) -> int or None:
+def to_int(value, default: int | None = 0, none_to_default: bool = True, suppress_warnings: bool = True) -> int | None:
     """
     Convert <value> to int.  Will always return integer or none instead of throwing exception
     @param value: value to be converted
@@ -201,7 +201,7 @@ def from_iso8601_compact(value: Any = None, tz: timezone = timezone.utc):
     return _value
 
 
-def to_date(value: Any = None, tz: timezone or None = timezone.utc, none_to_now: bool = True, suppress_warnings: bool = True):
+def to_date(value: Any = None, tz: timezone | None = timezone.utc, none_to_now: bool = True, suppress_warnings: bool = True):
     """
     Convert string to python date.  Currently, only concerned about iso8601 and db type formats.
     None returns current date by default but can be overridden with none_to_now optional parameter
@@ -232,7 +232,7 @@ def to_date(value: Any = None, tz: timezone or None = timezone.utc, none_to_now:
 
 
 # -------- helper conversions --------
-def to_mask(value: str or None) -> str or None:
+def to_mask(value: str | None) -> str | None:
     _mask = value
     if isinstance(value, str) and value is not None and len(value) > 0:
         # if we are less than 4 chars then mask the entire string

{python-ubercode-utils-2.0.0 → python_ubercode_utils-2.0.4}/ubercode/utils/data.py

@@ -9,7 +9,7 @@ import xml.etree.ElementTree as Etree
 from collections import defaultdict
 
 
-class JSON:
+class JsonData:
     """ simple json class to encapsulate basic json operations """
     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
@@ -49,7 +49,7 @@ class JSON:
         return str(self.data)
 
 
-class XML:
+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
@@ -95,7 +95,7 @@ class XML:
         output to dict
         :return: dict
         """
-        return XML.tree_to_dict(self.data)
+        return XmlData.tree_to_dict(self.data)
 
     @staticmethod
     def tree_to_dict(t: Etree) -> dict:
@@ -108,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()}}

{python-ubercode-utils-2.0.0 → python_ubercode_utils-2.0.4}/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-2.0.0 → python_ubercode_utils-2.0.4}/ubercode/utils/environment.py

@@ -6,8 +6,11 @@ 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
+from ubercode.utils.urls import DjUrl
 
 _utils_settings_logger = ColorLogger("utils.environment")
 
@@ -223,3 +226,99 @@ 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
+
+    def override_database_urls(self, db_dict: dict) -> dict:
+        """
+        Much like above,iterates over environment variables and overrides any database variables. However, instead
+        of looking for each variable with a pattern like DATABASES__default__ENGINE it looks for DJ_URL_ prefix and
+        parses the url into a DjUrl object.  This allows property files to use one line per database config
+        instead of one key,value pair per variable like: DJ_URL_default = 'django.db.backends.mysql://scott:tiger@localhost:1366/test'
+        NOTE: you can omit everything except what you want to replace like: '://:newpassword@' which
+        will only replace the password
+
+        :param db_dict: settings database dictionary to replace variables in ex: DATABASES
+        :return: new dict with updated overridden values
+        """
+        items = []
+        if hasattr(self._env_map, "items"):
+            items = self._env_map.items()
+        elif hasattr(os.environ, "items"):
+            items = os.environ.items()
+        for k, v in items:
+            # unlike override_database_variables() we will look for prefix DJ_URL_
+            if k and str(k).upper().startswith('DJ_URL_') and v:
+                # the actual key is the remaining part left
+                key = str(k)[len('DJ_URL_'):]
+                djurl = DjUrl(str(v))
+                for attr, value in vars(djurl).items():
+                    if value:
+                        if not db_dict.get(key):
+                            self._logger.warn(f'Missing database key [{key}]! creating...')
+                            db_dict[key] = {}
+                        _log_from_value = db_dict[key].get(attr.upper(), 'None')
+                        _log_to_value = value
+                        if attr.upper() in self._secret_properties:
+                            _log_to_value = convert.to_mask(value)
+                        db_dict[key][attr.upper()] = value
+                        self._logger.info(
+                            f'set [{key}][{attr.upper()}] from [{_log_from_value}] to [{_log_to_value}]')
+        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-2.0.0 → python_ubercode_utils-2.0.4}/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-2.0.0 → python_ubercode_utils-2.0.4}/ubercode/utils/urls.py

@@ -1,8 +1,8 @@
 import os
 from urllib.parse import urlsplit
-from ubercode.utils.convert import to_str
+from ubercode.utils.convert import to_str, to_int
 from pathlib import PurePath
-
+from .convert import to_mask
 
 class ParsedQueryString:
     """
@@ -216,6 +216,99 @@ class ParsedUrl:
         """
         return self.url
 
+class DjUrl:
+    engine = None
+    user = None
+    password = None
+    host = None
+    port = None
+    name = None
+
+    def __init__(self, dj_url: str = None) -> None:
+        """
+        parses a packed "django_url" into its parts following similar rules to SqlAlchemy
+        format: engine://user:password@host[:port]/dbname
+        example: django.db.backends.mysql://scott:tiger@localhost:1366/test
+
+        NOTE: asking for the string value will give back the original packed url masking the password
+        NOTE: to_dict will give back the dictionary values to be added or replaced in the DATABASES dict
+
+        :param url: packed django url  ex: django.db.backends.mysql://scott:tiger@localhost:1366/test
+        """
+        dj_url = dj_url or ""
+        dj_url = dj_url.strip()
+        encoded = False
+        if dj_url.endswith('?--atencoded'):
+            encoded = True
+            dj_url = dj_url[:-len('?--atencoded')].strip()
+        if not dj_url:
+            return
+        pos = dj_url.find('://')
+        if pos > -1:
+            self.engine = dj_url[:pos].strip() or None
+            constr = dj_url[pos + len('://'):].strip()
+        else:
+            constr = dj_url
+        pos = constr.find("@")
+        if pos > -1:
+            loginstr = constr[:pos].strip()
+            constr = constr[pos + len("@"):].strip()
+            pos = loginstr.find(':')
+            if pos > -1:
+                self.user = loginstr[:pos].strip() or None
+                self.password = loginstr[pos + len(':'):].strip() or None
+                if encoded:
+                    self.password = self.password.replace('%40', '@')
+            elif len(loginstr) > 0:
+                self.user = loginstr or None
+        else:
+            # since password is the most common replacement look for that specifically next if we didn't have an @
+            # NOTE: since password can contain / we will assume the only thing there is the password otherwise use @
+            # Ex: DjUrl(':newpassword/newdatabase') -> password=newpassword/newdatabase name=None
+            #     DjUrl(':newpassword@/newdatabase') -> password=newpassword name=newdatabase
+            #     DjUrl(':asfcasdf23%401:/!?--atencoded') -> password=asfcasdf23@1:/! name=None port=None
+            if constr.startswith(':'):
+                self.password = constr.strip(':')
+                constr = ''
+                if encoded:
+                    self.password = self.password.replace('%40', '@')
+        # NOTE: constr now contains everything after @ - no engine, user, password
+        # NOTE: may have port but no db ex: @:8080
+        pos = constr.find('/')
+        if pos > -1:
+            hoststr = constr[:pos].strip()
+            self.name = constr[pos + len('/'):].strip() or None
+        else:
+            hoststr = constr
+        # all that is left is hoststr
+        pos = hoststr.find(':')
+        if pos > -1:
+            self.host = hoststr[:pos].strip() or None
+            self.port = hoststr[pos + len(':'):].strip() or None
+            if self.port:
+                self.port = to_int(self.port, default=None, none_to_default=False)
+        elif len(hoststr) > 0:
+            self.host = hoststr
+
+    def to_dict(self) -> dict:
+        dct = {}
+        for attr, value in vars(self).items():
+            dct[attr.upper()] = value
+        return dct
+
+    def __str__(self) -> str:
+        url = f"{self.engine or ''}://"
+        if self.user:
+            url += self.user
+        if self.password:
+            url += f":{to_mask(self.password)}"
+        url += f"@{self.host or ''}"
+        if self.port:
+            url += f":{self.port}"
+        if self.name:
+            url += f"/{self.name}"
+        return url
+
 
 if __name__ == "__main__":
     # test_uri = "http://localhost:8000/test1/?id=1&x=2"

python-ubercode-utils-2.0.0/PKG-INFO

@@ -1,29 +0,0 @@
-Metadata-Version: 2.1
-Name: python-ubercode-utils
-Version: 2.0.0
-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-2.0.0/python_ubercode_utils.egg-info/PKG-INFO

@@ -1,29 +0,0 @@
-Metadata-Version: 2.1
-Name: python-ubercode-utils
-Version: 2.0.0
-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