postgresql-access 1.0__tar.gz

postgresql_access-1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 NMRhub
+
+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.

postgresql_access-1.0/PKG-INFO

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

@@ -0,0 +1,5 @@
+# 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

@@ -0,0 +1,20 @@
+[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

@@ -0,0 +1,19 @@
+[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

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

postgresql_access-1.0/src/postgresql_access/certificatedatabase.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+import os
+import pwd
+from typing import Mapping
+
+import psycopg2
+
+"""
+object wrapper for psycopg2
+"""
+
+def _current_user():
+    """get current linux user"""
+    return pwd.getpwuid(os.geteuid()).pw_name
+
+
+class CertificateDatabase:
+
+    def __init__(self,*,host:str,database:str,user:str,application_name:str,client_cert:str,client_key:str,
+                 root_cert:str):
+        self.app_name = 'Python app'
+        self.schema = None
+        self.port = 5432
+        self.host = host
+        self.database = database
+        self.user = user
+        self.application_name = application_name
+        self.client_cert = client_cert
+        self.client_key = client_key
+        self.root_cert = root_cert
+        files = (self.client_cert,self.client_key,self.root_cert)
+        missing = [f for f in files if not os.path.exists(f)]
+        if missing:
+            raise ValueError(f"Missing configuration file(s): {','.join(missing)}")
+        permissions = [f for f in files if not os.access(f,os.R_OK)]
+        if permissions:
+            raise ValueError(f"No read access file(s): {','.join(permissions)}")
+
+
+    def connect(self):
+        """Connect to database, set schema if present, return connection"""
+        connect_string = f"""host='{self.host}' dbname='{self.database}' user='{self.user}'  port={self.port}"""
+        try:
+            conn = psycopg2.connect(connect_string, application_name=self.application_name,
+                                    sslmode='verify-full',
+                                    sslcert=self.client_cert,
+                                    sslkey=self.client_key,sslrootcert=self.root_cert)
+        except psycopg2.OperationalError as oe:
+            if 'no password' in str(oe):
+                raise ValueError(f"Invalid certificates or key for user {self.user}, or not authorized by server")
+            raise
+        if self.schema is not None:
+            with conn.cursor() as cursor:
+                cursor.execute(f"set search_path to {self.schema}")
+            conn.commit()
+
+        return conn
+
+    @staticmethod
+    def create_from_dict(data:Mapping,application_name:str):
+        h = data['host']
+        d = data['database']
+        u = data.get('user',_current_user())
+        cc = data['client certificate']
+        rc = data['root certificate']
+        ck = data['client key']
+        return CertificateDatabase(host=h, database=d, user=u, application_name=application_name, client_cert=cc,
+                                   client_key=ck, root_cert=rc)
+

postgresql_access-1.0/src/postgresql_access/database.py

@@ -0,0 +1,328 @@
+#!/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/main.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+import argparse
+import logging
+from postgresql_access import postgresql_access_logger
+
+
+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()
+    postgresql_access_logger.setLevel(getattr(logging,args.loglevel))
+
+
+if __name__ == "__main__":
+    main()
+

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

@@ -0,0 +1,18 @@
+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/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+src/postgresql_access/__init__.py
+src/postgresql_access/certificatedatabase.py
+src/postgresql_access/database.py
+src/postgresql_access/main.py
+src/postgresql_access.egg-info/PKG-INFO
+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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+postgresql_access = postgresql_access.main:main

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

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

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

@@ -0,0 +1 @@
+postgresql_access