vmnp 0.1.0__tar.gz

vmnp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+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.

vmnp-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: vmnp
+Version: 0.1.0
+Summary: MySQL database helper with connection management and CRUD utilities
+Author-email: Mike Saysell <michael.saysell@ellipsedata.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: mysqlclient
+Requires-Dist: mysqlclient; extra == "mysqlclient"
+Provides-Extra: pymysql
+Requires-Dist: PyMySQL; extra == "pymysql"
+Dynamic: license-file
+
+DEPRECATED
+
+A helper class for database connections

vmnp-0.1.0/README.md

@@ -0,0 +1,3 @@
+DEPRECATED
+
+A helper class for database connections

vmnp-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vmnp"
+version = "0.1.0"
+authors = [
+    { name="Mike Saysell", email="michael.saysell@ellipsedata.com" }
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+description = "MySQL database helper with connection management and CRUD utilities"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.optional-dependencies]
+mysqlclient = ["mysqlclient"]
+pymysql = ["PyMySQL"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

vmnp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vmnp-0.1.0/src/vmnp/__init__.py

@@ -0,0 +1,3 @@
+from vmnp.db import Dbnp
+
+__all__ = ["Dbnp"]

vmnp-0.1.0/src/vmnp/db.py

@@ -0,0 +1,320 @@
+import sys
+import re
+
+try:
+    import MySQLdb
+except ImportError:
+    try:
+        import pymysql
+
+        pymysql.install_as_MySQLdb()
+    except:
+        sys.exit("one of MySQLdb (mysqlclient) or PyMySQL needs to be installed")
+
+import MySQLdb.converters
+from MySQLdb.constants import FIELD_TYPE
+
+### TODO: convert to connection pooling for thread-safe database connections
+# try:
+#    from DBUtils.PersistentDB import PersistentDB
+# except ImportError:
+#    pass
+#    # sys.exit("DBUtils needs to be installed")
+# https://cito.github.io/DBUtils/UsersGuide.html#functionality
+# https://stackoverflow.com/questions/47711689/error-while-using-pymysql-in-flask
+# https://stackoverflow.com/questions/32658679/how-to-create-a-mysql-connection-pool-or-any-better-way-to-initialize-the-multip
+# https://dev.mysql.com/doc/connector-python/en/connector-python-connection-pooling.html
+
+
+# Create a Dbnp class and a dbh handle
+class Dbnp:
+    dbh = None
+    config = {
+        "host": "localhost",
+        "port": 3306,
+        "db": "information_schema",
+        "user": "readonly",
+        "passwd": "",
+        "ssl": {
+            "ca": "/etc/mysql/ssl/ca-cert.pem",
+            "cert": "/etc/mysql/ssl/client-cert.pem",
+            "key": "/etc/mysql/ssl/client-key.pem",
+            "check_hostname": False,
+        },
+    }
+
+    convert_dict = MySQLdb.converters.conversions.copy()
+    # convert_dict[FIELD_TYPE.TINY] = str
+    # convert_dict[FIELD_TYPE.SHORT] = str
+    # convert_dict[FIELD_TYPE.LONG] = str
+    # convert_dict[FIELD_TYPE.FLOAT] = str
+    convert_dict[FIELD_TYPE.DOUBLE] = str
+    convert_dict[FIELD_TYPE.DECIMAL] = str
+    convert_dict[FIELD_TYPE.NEWDECIMAL] = str
+    # convert_dict[FIELD_TYPE.LONGLONG] = str
+    # convert_dict[FIELD_TYPE.INT24] = str
+    # convert_dict[FIELD_TYPE.YEAR] = str
+    # convert_dict[FIELD_TYPE.SET] = str
+    convert_dict[FIELD_TYPE.TIMESTAMP] = str
+    convert_dict[FIELD_TYPE.DATETIME] = str
+    convert_dict[FIELD_TYPE.TIME] = str
+    convert_dict[FIELD_TYPE.DATE] = str
+
+    def connect(self):
+        # TODO: read_default_file and read_default_group options!
+        self.dbh = MySQLdb.connect(
+            host=self.config["host"],
+            port=self.config["port"],
+            db=self.config["db"],
+            user=self.config["user"],
+            passwd=self.config["passwd"],
+            ssl=self.config["ssl"],
+            charset="utf8mb4",
+            use_unicode=True,
+            conv=self.convert_dict,
+        )
+        self.dbh.autocommit(True)
+
+    def reconnect(self):
+        try:
+            self.dbh.ping(True)
+            self.dbh.autocommit(
+                True
+            )  # ping seems to change it to True anyway, irrespective of original setting
+        except:
+            # ping doesn't reconnect if connection is closed: InterfaceError or 'MySQL server has gone away'
+            if self.dbh is not None and self.dbh.open:
+                self.dbh.close()
+            self.connect()
+
+    def dbconfig(self, host, port, db, user, passwd, ssl=None):
+        if host is not None:
+            self.config["host"] = host
+        if port is not None:
+            self.config["port"] = port
+        if db is not None:
+            self.config["db"] = db
+        if user is not None:
+            self.config["user"] = user
+        if passwd is not None:
+            self.config["passwd"] = passwd
+        if ssl is not None:
+            self.config["ssl"]["ca"] = ssl["ca"]
+            self.config["ssl"]["cert"] = ssl["cert"]
+            self.config["ssl"]["key"] = ssl["key"]
+
+    def cursor(self):
+        return self.dbh.cursor(MySQLdb.cursors.DictCursor)
+
+    def query(self, sql, vals=None):
+        try:
+            cursor = self.cursor()
+            # cursor.execute("SELECT @@autocommit")
+            # cursor.execute("SELECT CONNECTION_ID() AS connection_id")
+            # print(cursor.fetchone())
+            cursor.execute(sql, vals)
+        except AttributeError:
+            # database connection has never been opened
+            if self.dbh is None:
+                self.connect()
+                cursor = self.cursor()
+                cursor.execute(sql, vals)
+            else:
+                raise
+        except MySQLdb.InterfaceError:
+            # database connection has closed (eg, maxscale restarted)
+            self.reconnect()
+            cursor = self.cursor()
+            cursor.execute(sql, vals)
+        except MySQLdb.OperationalError as e:
+            errnum, errmsg = e.args
+            if errnum == 2006 or errnum == 2013:
+                # MySQL server has gone away
+                # Lost connection to MySQL server during query
+                self.reconnect()
+                cursor = self.cursor()
+                cursor.execute(sql, vals)
+            else:
+                raise
+        # self.dbh.commit() # disabled with autocommit=1. (needed as future selects will be part of the same transaction (REPEATABLE READ))
+        return cursor
+
+    def quote(self, s=None):
+        # return "'" + MySQLdb.escape_string(s).decode('utf-8') + "'"
+        return "'" + s.replace("'", "\\'") + "'"
+
+    def quote_identifier(self, s1=None, s2=None):
+        r = ""
+        for s in [s1, s2]:
+            if s is not None:
+                q = "`" + s.replace("`", "``") + "`"
+                if r == "":
+                    r = q
+                else:
+                    r = r + "." + q
+        return r
+
+    def rstr(self, r):
+        if r is not None and isinstance(r, dict):
+            for k, v in r.items():
+                if v is None:
+                    r[k] = None
+                elif isinstance(v, bytes):
+                    r[k] = v.decode("utf-8")
+                else:
+                    r[k] = str(v)
+
+    def error(self):
+        return MySQLdb.Error
+
+    def warning(self):
+        return MySQLdb.Warning
+
+    def __del__(self):
+        if self.dbh:
+            self.dbh.close()
+
+    #
+    # CRUD HELPERS
+    #
+
+    def create_row(self, db, table, row):
+        cols = []
+        hold = []
+        vals = []
+        for key, val in row.items():
+            cols.append(self.quote_identifier(key))
+            if val is not None and val.startswith("_now"):
+                m = re.search("^_now\((\d+)\)$", val)
+                if m:
+                    hold.append("NOW(%s)" % m.group(1))
+                else:
+                    hold.append("NOW()")
+            else:
+                hold.append("%s")
+                vals.append(val)
+
+        sql = "INSERT INTO %s (%s) VALUES (%s)" % (
+            self.quote_identifier(db, table),
+            ",".join(cols),
+            ",".join(hold),
+        )
+        return self.query(sql, vals)
+
+    def read_row(self, db, table, keys, vals):
+        keys, vals = self._get_keys_vals(keys, vals)
+        where = self._make_where(keys)
+        sql = "SELECT * FROM %s WHERE %s" % (self.quote_identifier(db, table), where)
+        cur = self.query(sql, vals)
+        return cur.fetchone()
+
+    def update_row(self, db, table, row, keys, vals=None):
+        keys, vals = self._get_keys_vals(keys, vals, row)
+        do_create = False
+        if len(vals) > 0:
+            res = self.read_row(db, table, keys, vals)
+            if res:
+                # TODO: compare vals with res, only update the columns that have changed
+                upset = []
+                upval = []
+                for key, val in row.items():
+                    if val is not None and val.startswith("_now"):
+                        m = re.search("^_now\((\d+)\)$", val)
+                        if m:
+                            upset.append(
+                                self.quote_identifier(key) + "=NOW(%s)" % m.group(1)
+                            )
+                        else:
+                            upset.append(self.quote_identifier(key) + "=NOW()")
+                    else:
+                        upset.append(self.quote_identifier(key) + "=%s")
+                        upval.append(val)
+                upval += vals
+                where = self._make_where(keys)
+                sql = "UPDATE %s SET %s WHERE %s" % (
+                    self.quote_identifier(db, table),
+                    ", ".join(upset),
+                    where,
+                )
+                return self.query(sql, upval)
+            else:
+                do_create = True
+        else:
+            do_create = True
+
+        if do_create:
+            return self.create_row(db, table, row)
+
+    def delete_row(self, db, table, keys, vals):
+        keys, vals = self._get_keys_vals(keys, vals)
+        where = self._make_where(keys)
+        sql = "DELETE FROM %s WHERE %s" % (self.quote_identifier(db, table), where)
+        return self.query(sql, vals)
+
+    def _get_keys_vals(self, keys, vals, row=None):
+        if keys is None:
+            keys = []
+        if vals is None:
+            vals = []
+        if row is None:
+            row = {}
+
+        if type(keys) != list:
+            keys = [keys]
+        if type(vals) != list:
+            vals = [vals]
+
+        if not vals and keys:
+            if type(keys) == list:
+                for k in keys:
+                    if k in row:
+                        vals.append(row[k])
+                    else:
+                        break
+            elif keys in row:
+                vals.append(row[keys])
+
+        return keys, vals
+
+    def _make_where(self, keys=None):
+        if keys is None:
+            where = "1"
+        elif type(keys) == list:
+            ws = []
+            for k in keys:
+                ws.append(self.quote_identifier(k) + "=%s")
+            where = " AND ".join(ws)
+        else:
+            where = self.quote_identifier(keys) + "=%s"
+
+        return where
+
+
+"""
+From the MySQLdb User Guide:
+
+    The MySQL protocol can not handle multiple threads using the same
+    connection at once. Some earlier versions of MySQLdb utilized
+    locking to achieve a threadsafety of 2. While this is not terribly
+    hard to accomplish using the standard Cursor class (which uses
+    mysql_store_result()), it is complicated by SSCursor (which uses
+    mysql_use_result(); with the latter you must ensure all the rows
+    have been read before another query can be executed. It is further
+    complicated by the addition of transactions, since transactions
+    start when a cursor execute a query, but end when COMMIT or
+    ROLLBACK is executed by the Connection object. Two threads simply
+    cannot share a connection while a transaction is in progress, in
+    addition to not being able to share it during query execution.
+    This excessively complicated the code to the point where it just
+    isn't worth it.
+
+    The general upshot of this is: Don't share connections between
+    threads. It's really not worth your effort or mine, and in the
+    end, will probably hurt performance, since the MySQL server runs a
+    separate thread for each connection. You can certainly do things
+    like cache connections in a pool, and give those connections to
+    one thread at a time. If you let two threads use a connection
+    simultaneously, the MySQL client library will probably upchuck and
+    die. You have been warned.
+
+"""

vmnp-0.1.0/src/vmnp.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: vmnp
+Version: 0.1.0
+Summary: MySQL database helper with connection management and CRUD utilities
+Author-email: Mike Saysell <michael.saysell@ellipsedata.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: mysqlclient
+Requires-Dist: mysqlclient; extra == "mysqlclient"
+Provides-Extra: pymysql
+Requires-Dist: PyMySQL; extra == "pymysql"
+Dynamic: license-file
+
+DEPRECATED
+
+A helper class for database connections

vmnp-0.1.0/src/vmnp.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/vmnp/__init__.py
+src/vmnp/db.py
+src/vmnp.egg-info/PKG-INFO
+src/vmnp.egg-info/SOURCES.txt
+src/vmnp.egg-info/dependency_links.txt
+src/vmnp.egg-info/requires.txt
+src/vmnp.egg-info/top_level.txt

vmnp-0.1.0/src/vmnp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vmnp-0.1.0/src/vmnp.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[mysqlclient]
+mysqlclient
+
+[pymysql]
+PyMySQL

vmnp-0.1.0/src/vmnp.egg-info/top_level.txt

@@ -0,0 +1 @@
+vmnp