postgresql-access 1.0__tar.gz → 2.0__tar.gz

postgresql_access-2.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: postgresql_access
+Version: 2.0
+Author-email: Gerard <gweatherby@uchc.edu>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: keyring
+Provides-Extra: psycopg2
+Requires-Dist: psycopg2-binary; extra == "psycopg2"
+Provides-Extra: psycopg3
+Requires-Dist: psycopg[binary]; extra == "psycopg3"
+Provides-Extra: alchemy
+Requires-Dist: sqlalchemy; extra == "alchemy"
+Dynamic: license-file
+
+# postgresql_access
+Helper functions for connecting to Postgresql. Either psycopg2 or psycopg3 should be installed.
+
+## install options
+* pip install postgresql_access
+* pip install postgresql_access[psycopg2]
+* pip install postgresql_access[psycopg3]
+
+
+## keyring
+You must install a [keyring](https://pypi.org/project/keyring/) in your Python environment to use this package.

postgresql_access-2.0/README.md

@@ -0,0 +1,11 @@
+# postgresql_access
+Helper functions for connecting to Postgresql. Either psycopg2 or psycopg3 should be installed.
+
+## install options
+* pip install postgresql_access
+* pip install postgresql_access[psycopg2]
+* pip install postgresql_access[psycopg3]
+
+
+## keyring
+You must install a [keyring](https://pypi.org/project/keyring/) in your Python environment to use this package.

postgresql_access-2.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "postgresql_access"
+version = "2.0"
+dependencies = [
+    "keyring"
+]
+requires-python = ">=3.8"
+
+authors = [
+    { name = "Gerard", email = "gweatherby@uchc.edu" }
+]
+
+readme = "README.md"
+license = { text = "MIT" }
+dynamic = []
+
+[project.scripts]
+postgresql_access = "postgresql_access.main:main"
+
+[project.optional-dependencies]
+psycopg2 = ["psycopg2-binary"]
+psycopg3 = ["psycopg[binary]"]
+alchemy = ["sqlalchemy"]
+
+[build-system]
+requires = ["setuptools>=80", "wheel"]
+build-backend = "setuptools.build_meta"
+

postgresql_access-2.0/setup.cfg

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

postgresql_access-2.0/src/alchemy/satest.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+import argparse
+import logging
+_logger = logging.getLogger(__name__)
+
+
+def main():
+    logging.basicConfig()
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('-l', '--loglevel', default='WARN', help="Python logging level")
+
+    args = parser.parse_args()
+    _logger.setLevel(getattr(logging,args.loglevel))
+
+
+if __name__ == "__main__":
+    main()

postgresql_access-2.0/src/postgresql_access/__init__.py

@@ -0,0 +1,9 @@
+import importlib.metadata
+import logging
+
+postgresql_access_logger = logging.getLogger(__name__)
+
+__version__ = importlib.metadata.version('postgresql_access')
+
+from postgresql_access.database import AbstractDatabase, DatabaseConfig, DatabaseDict, ReadOnlyCursor, NewTransactionCursor
+from postgresql_access.database import SelfCloseCursor, SelfCloseConnection

postgresql_access-2.0/src/postgresql_access/database.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+
+import configparser
+import getpass
+import os
+import pwd
+from abc import ABC, abstractmethod
+from typing import Mapping, Any
+
+import keyring
+
+# Compatibility layer for psycopg2 and psycopg3
+try:
+    import psycopg
+    psycopg_module = 'psycopg3'
+    connect = psycopg.connect
+    OperationalError = psycopg.OperationalError
+except ImportError:
+    import psycopg2 as psycopg
+    psycopg_module = 'psycopg2'
+    connect = psycopg.connect
+    OperationalError = psycopg.OperationalError
+
+
+class AbstractDatabase(ABC):
+    __DATABASE = 'database'
+
+    def __init__(self):
+        self._app_name = 'Python app'
+        self.schema = None
+        self.port = 5432
+        self._sslmode = None
+
+    @abstractmethod
+    def host(self) -> str: pass
+
+    @abstractmethod
+    def database_name(self) -> str: pass
+
+    @abstractmethod
+    def user(self) -> str: pass
+
+    @abstractmethod
+    def password(self) -> str: pass
+
+    def set_app_name(self, name):
+        self._app_name = name
+
+    def application_name(self):
+        return self._app_name
+
+    def require_ssl(self):
+        self._sslmode = 'require'
+
+    def connect_fail(self, database, user, password, schema):
+        pass
+
+    def connect_success(self, database, user, password, schema):
+        pass
+
+    def build_connection_kwargs(self, dbname, user, password):
+        kwargs = dict(
+            host=self.host(),
+            dbname=dbname,
+            user=user,
+            password=password,
+            port=self.port,
+            application_name=self._app_name,
+        )
+        if self._sslmode:
+            kwargs['sslmode'] = self._sslmode
+        return kwargs
+
+    def connect(self, *, database_name: str = None, application_name: str = None, schema: str = None, **kwargs):
+        if application_name is not None:
+            self.set_app_name(application_name)
+        dbname = database_name or self.database_name()
+        user = self.user()
+        password = self.password()
+
+        try:
+            conn = connect(**self.build_connection_kwargs(dbname, user, password), **kwargs)
+            self.connect_success(dbname, user, password, schema)
+        except OperationalError:
+            self.connect_fail(dbname, user, password, schema)
+            raise
+
+        if schema:
+            with conn.cursor() as cursor:
+                cursor.execute(f"SET search_path TO {schema}")
+            conn.commit()
+
+        return conn
+
+class DatabaseSimple(AbstractDatabase):
+    def __init__(self, *, host: str, port: int = 5432, user: str, database_name: str):
+        super().__init__()
+        self._host = host
+        self.port = port
+        self.username = user
+        self._dbname = database_name
+
+    def host(self) -> str: return self._host
+    def database_name(self) -> str: return self._dbname
+
+    def user(self) -> str:
+        if not self.username:
+            u = input("database user: ")
+            self.username = u.strip()
+        return self.username
+
+    @property
+    def service_name(self):
+        return f"Database {self.host()}.{self.database_name()}"
+
+    def set_password(self, password) -> None:
+        keyring.set_password(self.service_name, self.user(), password)
+
+    def password(self) -> str:
+        if (pw := keyring.get_password(self.service_name, self.user())) is not None:
+            return pw
+        pw = getpass.getpass(f"Enter password for {self.service_name} {self.user()}")
+        return pw
+
+    def connect_success(self, database, user, password, schema):
+        self.set_password(password)
+        super().connect_success(database, user, password, schema)
+
+class DatabaseDict(DatabaseSimple):
+    def __init__(self, *, dictionary: Mapping):
+        host = dictionary['host']
+        user = dictionary.get('user', None)
+        if user == 'linux user':
+            user = pwd.getpwuid(os.geteuid()).pw_name
+        dbname = dictionary['database']
+        port = int(dictionary.get('port', 5432))
+        super().__init__(host=host, port=port, user=user, database_name=dbname)
+
+class DatabaseConfig(DatabaseDict):
+    def __init__(self, *, config: 'configparser.ConfigParser', section_key: str = 'database',
+                 application_name: str = None):
+        config_section = config[section_key]
+        super().__init__(dictionary=config_section)
+        self.set_app_name(application_name)
+
+class SelfCloseConnection:
+    def __init__(self, conn): self._conn = conn
+    def __enter__(self): return self._conn
+    def __exit__(self, exc_type, exc_val, exc_tb): self._conn.close()
+
+class SelfCloseCursor:
+    def __init__(self, conn): self._conn = conn
+    def __enter__(self): return self._conn.cursor()
+    def __exit__(self, exc_type, exc_val, exc_tb): self._conn.close()
+    @property
+    def connection(self): return self._conn
+
+class ReadOnlyCursor:
+    def __init__(self, conn, cursor_factory=None):
+        self._conn = conn
+        self._factory = cursor_factory
+
+    def __enter__(self):
+        self.existing_readonly = self._conn.readonly
+        self._conn.readonly = True
+        self._curs = self._conn.cursor(cursor_factory=self._factory)
+        return self._curs
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._curs.close()
+        self._conn.rollback()
+        self._conn.readonly = self.existing_readonly
+
+    @property
+    def connection(self): return self._conn
+
+class NewTransactionCursor:
+    def __init__(self, conn, cursor_factory=None):
+        self._conn = conn
+        self._factory = cursor_factory
+
+    def __enter__(self):
+        self._conn.rollback()
+        return self._conn.cursor(cursor_factory=self._factory)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            self._conn.rollback()
+        else:
+            self._conn.commit()
+
+    @property
+    def connection(self): return self._conn
+
+class Qobject:
+    def __str__(self) -> str:
+        return ''.join(f"{k}: {v}\n" for k, v in self.__dict__.items() if not k.startswith('_'))
+
+def query_to_object(cursor, query: str) -> list:
+    cursor.execute(query)
+    return cursor_to_objects(cursor)
+
+def cursor_to_objects(cursor) -> list:
+    rval = []
+    rows = cursor.fetchall()
+    cols = [d[0] for d in cursor.description]
+    for r in rows:
+        qo = Qobject()
+        for col, val in zip(cols, r):
+            setattr(qo, col, val)
+        rval.append(qo)
+    return rval
+
+def update_object_in_database(cursor: Any, obj, table: str, key: str) -> None:
+    query = f"UPDATE {table} SET "
+    sets, values, keyvalue = [], [], None
+    for field, value in obj.__dict__.items():
+        if field != key:
+            sets.append(f"{field} = %s")
+            values.append(value)
+        else:
+            keyvalue = value
+    if keyvalue is None:
+        raise ValueError(f"Key attribute {key} not found")
+    query += ','.join(sets) + f" WHERE {key} = %s"
+    values.append(keyvalue)
+    cursor.execute(query, values)
+    if cursor.rowcount != 1:
+        raise ValueError(f"No update for {table}.{key} value {keyvalue}")
+
+def row_estimate(connection, table: str) -> int:
+    with connection.cursor() as curs:
+        curs.execute("""SELECT reltuples::bigint FROM pg_catalog.pg_class WHERE relname = %s""", (table,))
+        row = curs.fetchone()
+        return int(row[0])
+

postgresql_access-2.0/src/postgresql_access.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: postgresql_access
+Version: 2.0
+Author-email: Gerard <gweatherby@uchc.edu>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: keyring
+Provides-Extra: psycopg2
+Requires-Dist: psycopg2-binary; extra == "psycopg2"
+Provides-Extra: psycopg3
+Requires-Dist: psycopg[binary]; extra == "psycopg3"
+Provides-Extra: alchemy
+Requires-Dist: sqlalchemy; extra == "alchemy"
+Dynamic: license-file
+
+# postgresql_access
+Helper functions for connecting to Postgresql. Either psycopg2 or psycopg3 should be installed.
+
+## install options
+* pip install postgresql_access
+* pip install postgresql_access[psycopg2]
+* pip install postgresql_access[psycopg3]
+
+
+## keyring
+You must install a [keyring](https://pypi.org/project/keyring/) in your Python environment to use this package.

{postgresql_access-1.0 → postgresql_access-2.0}/src/postgresql_access.egg-info/SOURCES.txt

@@ -1,7 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
-setup.cfg
+src/alchemy/satest.py
 src/postgresql_access/__init__.py
 src/postgresql_access/certificatedatabase.py
 src/postgresql_access/database.py
@@ -11,4 +11,6 @@ src/postgresql_access.egg-info/SOURCES.txt
 src/postgresql_access.egg-info/dependency_links.txt
 src/postgresql_access.egg-info/entry_points.txt
 src/postgresql_access.egg-info/requires.txt
-src/postgresql_access.egg-info/top_level.txt
+src/postgresql_access.egg-info/top_level.txt
+src/tests/atest.py
+src/tests/grouptest.py

postgresql_access-2.0/src/postgresql_access.egg-info/requires.txt

@@ -0,0 +1,10 @@
+keyring
+
+[alchemy]
+sqlalchemy
+
+[psycopg2]
+psycopg2-binary
+
+[psycopg3]
+psycopg[binary]

{postgresql_access-1.0 → postgresql_access-2.0}/src/postgresql_access.egg-info/top_level.txt

@@ -1 +1,3 @@
+alchemy
 postgresql_access
+tests

postgresql_access-2.0/src/tests/atest.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+import argparse
+import configparser
+import logging
+
+import keyring
+from keyring import backend
+
+from postgresql_access import postgresql_access_logger
+from postgresql_access.database import DatabaseConfig
+
+
+def main():
+#    for kr in backend.get_all_keyring():
+#        print(kr)
+    kr = keyring.get_keyring()
+    print(kr)
+    logging.basicConfig()
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('-l', '--loglevel', default='WARN', help="Python logging level")
+    parser.add_argument('config',help="ini style config")
+
+    args = parser.parse_args()
+    postgresql_access_logger.setLevel(getattr(logging,args.loglevel))
+    cp = configparser.ConfigParser()
+    with open(args.config) as f:
+        cp.read_file(f)
+
+    db = DatabaseConfig(config=cp)
+    c = db.connect(application_name="access test")
+    with c.cursor() as cursor:
+        cursor.execute('select now()')
+        print(cursor.fetchone()[0])
+
+
+if __name__ == "__main__":
+    main()

postgresql_access-2.0/src/tests/grouptest.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+import argparse
+import configparser
+import logging
+
+import keyring
+from keyring import backend
+
+from postgresql_access import postgresql_access_logger
+from postgresql_access.database import DatabaseConfig
+
+
+def main():
+#    for kr in backend.get_all_keyring():
+#        print(kr)
+    kr = keyring.get_keyring()
+    print(kr)
+    logging.basicConfig()
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('-l', '--loglevel', default='WARN', help="Python logging level")
+    parser.add_argument('config',help="ini style config")
+
+    args = parser.parse_args()
+    postgresql_access_logger.setLevel(getattr(logging,args.loglevel))
+    cp = configparser.ConfigParser()
+    with open(args.config) as f:
+        cp.read_file(f)
+
+    db = DatabaseConfig(config=cp)
+    c = db.connect(application_name="access test")
+    with c.cursor() as cursor:
+        cursor.execute('select now()')
+        print(cursor.fetchone()[0])
+
+
+if __name__ == "__main__":
+    main()

postgresql_access-1.0/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 2.1
-Name: postgresql_access
-Version: 1.0
-Home-page: https://github.com/NMRhub/postgresql_access.git
-Author: Gerard
-Author-email: gweatherby@uchc.edu
-License: MIT license
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: psycopg2-binary
-Requires-Dist: keyring
-
-# postgresql_access
-Helper functions for connecting to Postgresql
-
-## keyring
-You must install a [keyring](https://pypi.org/project/keyring/) in your Python environment to use this package.

postgresql_access-1.0/README.md

@@ -1,5 +0,0 @@
-# postgresql_access
-Helper functions for connecting to Postgresql
-
-## keyring
-You must install a [keyring](https://pypi.org/project/keyring/) in your Python environment to use this package.

postgresql_access-1.0/pyproject.toml

@@ -1,20 +0,0 @@
-[project]
-name = "postgresql_access"
-version = "1.0"
-dependencies = ['psycopg2-binary',
-	'keyring']
-requires-python= ">= 3.8"
-authors = [
-    {name = "Gerard"},
-    {email = "gweatherby@uchc.edu"}
-]
-dynamic = ["license"] 
-readme = "README.md"
-
-[project.scripts]
-postgresql_access = "postgresql_access.main:main"
-
-[build-system]
-requires = ["setuptools"]
-build-backend = "setuptools.build_meta"
-

postgresql_access-1.0/setup.cfg

@@ -1,19 +0,0 @@
-[metadata]
-description = TBD
-license = MIT license
-url = https://github.com/NMRhub/postgresql_access.git
-
-[options]
-package_dir = 
-	= src
-packages = 
-	postgresql_access
-install_requires = 
-
-[build_ext]
-debug = 1
-
-[egg_info]
-tag_build = 
-tag_date = 0
-

postgresql_access-1.0/src/postgresql_access/__init__.py

@@ -1,7 +0,0 @@
-
-import importlib.metadata 
-import logging
-postgresql_access_logger = logging.getLogger(__name__)
-
-__version__ =  importlib.metadata.version('postgresql_access') 
-

postgresql_access-1.0/src/postgresql_access/database.py

@@ -1,328 +0,0 @@
-#!/usr/bin/env python3
-import configparser
-import getpass
-import os
-import pwd
-from abc import ABC, abstractmethod
-from typing import Mapping
-
-import keyring
-import psycopg2
-import psycopg2.extensions
-
-"""
-object wrapper for psycopg2
-database utility functions / classes
-"""
-
-class AbstractDatabase(ABC):
-    """OO wrapper for psycopg2 and Facade to connect PasswordCache"""
-    __DATABASE = 'database'
-    """Password cache context"""
-
-    def __init__(self):
-        self._app_name = 'Python app'
-        self.schema = None
-        self.port = 5432
-        self._sslmode = None
-
-    @abstractmethod
-    def host(self) -> str:
-        pass
-
-    @abstractmethod
-    def database_name(self) -> str:
-        pass
-
-    @abstractmethod
-    def user(self) -> str:
-        pass
-
-    @abstractmethod
-    def password(self) -> str:
-        pass
-
-    def set_app_name(self, name):
-        """set application name"""
-        self._app_name = name
-
-    def application_name(self):
-        return self._app_name
-
-    def require_ssl(self):
-        """Require SSL connection"""
-        self._sslmode = 'require'
-
-    def connect_fail(self, database, user, password, schema):
-        """Overridable callback when connect fails"""
-        pass
-
-    def connect_success(self, database, user, password, schema):
-        """Overridable callback when connect fails"""
-        pass
-
-    def connect(self, *, database_name: str = None, application_name: str = None, schema: str = None,
-                **kwargs):
-        """Connect to database, set schema if present, return connection
-        :param database_name: use instead of self.database_name()
-        :param application_name: name to use for connection string
-        :param schema: use instead of self.schema
-        :return database connection
-        """
-        if application_name is not None:
-            appname = application_name
-        else:
-            appname = self.application_name()
-        if schema is not None:
-            sch = schema
-        else:
-            sch = self.schema
-        if database_name is not None:
-            dbname = database_name
-        else:
-            dbname = self.database_name()
-        user = self.user()
-        password = self.password()
-        connect_string = f"host='{self.host()}' dbname='{dbname}' user='{user}' password='{password}' port={self.port}"
-        if self._sslmode:
-            connect_string += f" sslmode='{self._sslmode}'"
-        try:
-            conn = psycopg2.connect(connect_string, application_name=appname,**kwargs)
-            self.connect_success(dbname, user, password, sch)
-        except psycopg2.OperationalError:
-            self.connect_fail(dbname, user, password, sch)
-            raise
-        if sch is not None:
-            with conn.cursor() as cursor:
-                cursor.execute("set search_path to {}".format(sch))
-            conn.commit()
-
-        return conn
-
-
-class DatabaseSimple(AbstractDatabase):
-    """
-    Create by specifying parameters
-    """
-
-    def __init__(self, *, host: str, port: int = 5432, user: str, database_name: str):
-        super().__init__()
-        self._host = host
-        self.port = port
-        self.username = user
-        self._dbname = database_name
-        self.ctx = None
-        self._pobj = None
-
-    def host(self) -> str:
-        return self._host
-
-    def database_name(self) -> str:
-        return self._dbname
-
-    def user(self) -> str:
-        if not self.username:
-            u = input("database user: ")
-            self.username = u.strip()
-        return self.username
-
-    @property
-    def service_name(self):
-        return f"Database {self.host()}.{self.database_name()}"
-
-    def set_password(self,password) -> None:
-        """"Set password explicitly"""
-        keyring.set_password(self.service_name,self.user(),password)
-
-    def password(self) -> str:
-        """Get password from keyring or prompt"""
-        if (pw := keyring.get_password(self.service_name,self.user())) is not None:
-             return pw
-        pw = getpass.getpass(f"Enter password for {self.service_name} {self.user()}")
-        return pw
-
-    def connect_success(self, database, user, password, schema):
-        self.set_password(password)
-        super().connect_success(database, user, password, schema)
-
-
-class DatabaseDict(DatabaseSimple):
-    """
-    Create from dictionary with host/user/database keys
-    """
-
-    def __init__(self, *, dictionary: Mapping):
-        host = dictionary['host']
-        user = dictionary.get('user', None)
-        if user == 'linux user':
-            user = pwd.getpwuid(os.geteuid()).pw_name
-        dbname = dictionary['database']
-        port = int(dictionary.get('port', 5432))
-        super().__init__(host=host, port=port, user=user, database_name=dbname)
-
-
-class DatabaseConfig(DatabaseDict):
-
-    def __init__(self, *, config: 'configparser.ConfigParser', section_key: str = 'database',
-                 application_name:str = None):
-        config_section = config[section_key]
-        super().__init__(dictionary=config_section)
-        self.set_app_name(application_name)
-
-
-class SelfCloseConnection:
-    """A ContextManger connection which closes itself when it goes out of scope"""
-
-    def __init__(self, conn):
-        self._conn = conn
-
-    def __enter__(self):
-        return self._conn
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._conn.close()
-
-
-class SelfCloseCursor:
-    """A ContextManger cursor which closes the connection when it goes out of scope"""
-
-    def __init__(self, conn) -> None:
-        self._conn = conn
-
-    def __enter__(self):
-        return self._conn.cursor()
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._conn.close()
-
-    @property
-    def connection(self):
-        """Return connection"""
-        return self._conn
-
-
-class ReadOnlyCursor:
-    """A ContextManager cursor which sets the session to readonly. Fails if current transaction is in place"""
-
-    def __init__(self, conn, cursor_factory=None) -> None:
-        self._conn = conn
-        self._factory = cursor_factory
-
-    def __enter__(self):
-        self.existing_readonly = self._conn.readonly
-        self._conn.readonly = True
-        self._curs = self._conn.cursor(cursor_factory=self._factory)
-        return self._curs
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self._curs.close()
-        self._conn.rollback()
-        self._conn.readonly = self.existing_readonly
-
-    @property
-    def connection(self):
-        """Return connection"""
-        return self._conn
-
-
-class NewTransactionCursor:
-    """A ContextManger cursor which starts a new transaction (rollbacks any current SQL) statements,
-    and commits in on normal exit"""
-
-    def __init__(self, conn, cursor_factory=None) -> None:
-        self._conn = conn
-        self._factory = cursor_factory
-
-    def __enter__(self):
-        self._conn.rollback()
-        return self._conn.cursor(cursor_factory=self._factory)
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if exc_type is not None:
-            self._conn.rollback()
-        else:
-            self._conn.commit()
-
-    @property
-    def connection(self):
-        """Return connection"""
-        return self._conn
-
-
-class Qobject:
-    """Auto object generated from results of query"""
-
-    def __str__(self) -> str:
-        rval = ""
-        for k, v in self.__dict__.items():
-            if not k.startswith('_'):
-                rval += k + ": " + str(v) + '\n'
-        return rval
-
-
-def query_to_object(cursor, query: str) -> list:
-    """
-    Convert generic query into list of objects
-    :param cursor:
-    :param query:
-    :return: list of Objects with fields named after columns in query
-    """
-    cursor.execute(query)
-    return cursor_to_objects(cursor)
-
-def cursor_to_objects(cursor) -> list:
-    """
-    Convert cursor results to list of objects
-    :param cursor: cursor that has just executed query
-    :return: list of Objects with fields named after columns in query
-    """
-    rval = []
-    rows = cursor.fetchall()
-    cols = [d[0] for d in cursor.description]
-    ncols = len(cols)
-    for r in rows:
-        qo = Qobject()
-        for i in range(ncols):
-            v = r[i]
-            setattr(qo, cols[i], v)
-        rval.append(qo)
-    return rval
-
-
-def update_object_in_database(cursor: psycopg2.extensions.cursor, object, table: str, key: str) -> None:
-    """update an object whose fields match columns names into database
-    :param cursor: open cursor with write access
-    :param object: data source
-    :param table: name of table to update
-    :param key: primary key column name (only single key supported)
-    :raises ValueError if key value not found on object or single row not updated
-    """
-    query = "update {} set ".format(table)
-    sets = []
-    values = []
-    keyvalue = None
-    for field, value in object.__dict__.items():
-        if field != key:
-            sets.append('{} = %s'.format(field))
-            values.append(value)
-        else:
-            keyvalue = value
-    if keyvalue is None:
-        raise ValueError("Key attribute {} not found on {}".format(key, object))
-    query += ','.join(sets)
-    query += ' where {} = %s'.format(key)
-    values.append(keyvalue)
-    cursor.execute(query, values)
-    if cursor.rowcount != 1:
-        raise ValueError("No update for {}.{} value {}".format(table, key, keyvalue))
-
-
-def row_estimate(connection, table: str) -> int:
-    """A quick estimate about how many rows
-    are in a table. +/ 10%"""
-    with connection.cursor() as curs:
-        curs.execute("""SELECT reltuples::bigint
-        FROM pg_catalog.pg_class
-        WHERE relname = %s""", (table,))
-        row = curs.fetchone()
-        return int(row[0])

postgresql_access-1.0/src/postgresql_access.egg-info/PKG-INFO

@@ -1,18 +0,0 @@
-Metadata-Version: 2.1
-Name: postgresql_access
-Version: 1.0
-Home-page: https://github.com/NMRhub/postgresql_access.git
-Author: Gerard
-Author-email: gweatherby@uchc.edu
-License: MIT license
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: psycopg2-binary
-Requires-Dist: keyring
-
-# postgresql_access
-Helper functions for connecting to Postgresql
-
-## keyring
-You must install a [keyring](https://pypi.org/project/keyring/) in your Python environment to use this package.

postgresql_access-1.0/src/postgresql_access.egg-info/requires.txt

@@ -1,2 +0,0 @@
-psycopg2-binary
-keyring