hdx-python-database 1.3.1__tar.gz → 1.3.2__tar.gz

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/.config/pre-commit-config.yaml

@@ -1,14 +1,14 @@
 default_language_version:
-    python: python3.11
+    python: python3.12
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v4.6.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
       - id: check-ast
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.2
+    rev: v0.5.6
     hooks:
       # Run the linter.
       - id: ruff
@@ -17,7 +17,7 @@ repos:
       - id: ruff-format
         args: [--config, .config/ruff.toml]
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.1.38
+    rev: 0.2.33
     hooks:
       # Run the pip compile
       - id: pip-compile

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/.github/workflows/publish.yaml

@@ -9,19 +9,20 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Get history and tags for versioning to work
       run: |
         git fetch --prune --unshallow
         git fetch --depth=1 origin +refs/tags/*:refs/tags/*
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install --upgrade hatch
+    - name: Install Hatch
+      uses: pypa/hatch@install
     - name: Build with hatch
       run: |
         hatch build

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/.github/workflows/run-python-tests.yaml

@@ -18,22 +18,23 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install --upgrade hatch
+    - name: Install Hatch
+      uses: pypa/hatch@install
     - name: Test with hatch/pytest
       run: |
-        hatch run test:test
+        hatch test
     - name: Check styling
       if: always()
       run: |
-        hatch run lint:style
+        hatch fmt --check
     - name: Publish Unit Test Results
       uses: EnricoMi/publish-unit-test-result-action@v2
       if: always()

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: hdx-python-database
-Version: 1.3.1
+Version: 1.3.2
 Summary: HDX Python database utilities
 Project-URL: Homepage, https://github.com/OCHA-DAP/hdx-python-database
 Author-email: Michael Rans <rans@email.com>

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/documentation/main.md

@@ -105,6 +105,10 @@ maps don't work with reflection and hence `db_has_tz` will be ignored ie.
 there will be no conversion between Python datetimes with timezones to
 timezoneless database columns.
 
+A PostgreSQL database can be restored from a file generated by the `pg_dump`
+command line utility by supplying `pg_restore_file` with the path to the file
+to be restored.
+
 There is an option to wipe and create an empty schema in the database by
 setting `recreate_schema` to `True` and setting a `schema_name` ("public" is
 the default).
@@ -178,9 +182,16 @@ View preparation must be done before calling Base.metadata.create_all.
 
 ## PostgreSQL specific
 
-There is a PostgreSQL specific call that only returns when the PostgreSQL database
-is available:
+There is a PostgreSQL specific call that only returns when the PostgreSQL
+database becomes available:
 
     # Wait until PostgreSQL is up
     # Library should be installed with hdx-python-database[postgresql]
-    wait_for_postgresql("mydatabase", "myserver", 5432, "myuser", "mypass")
+    db_uri = "postgresql+psycopg://myuser:mypass@1.2.3.4:12345/mydatabase"
+    wait_for_postgresql(db_uri)
+
+The database can be restored from a file generated by `pg_dump` like this:
+
+    db_uri = "postgresql+psycopg://myuser:mypass@1.2.3.4:12345/mydatabase"
+    pg_restore_file = "backup.pg_restore"
+    assert restore_from_pgfile(db_uri, pg_restore_file) == "WORKED!"

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/pyproject.toml

@@ -75,25 +75,21 @@ version_scheme = "python-simplified-semver"
 
 # Tests
 
-[tool.hatch.envs.test]
+[tool.hatch.envs.hatch-test]
 features = ["sshtunnel", "postgresql", "test"]
 
-[tool.hatch.envs.test.scripts]
-test = """
+[[tool.hatch.envs.hatch-test.matrix]]
+python = ["3.12"]
+
+[tool.hatch.envs.hatch-test.scripts]
+run = """
        pytest -c .config/pytest.ini --rootdir=. --junitxml=test-results.xml \
        --cov --cov-config=.config/coveragerc --no-cov-on-fail \
-       --cov-report=lcov --cov-report=term-missing
+       --cov-report=lcov --cov-report=term-missing -p no:randomly
        """
 
-[[tool.hatch.envs.test.matrix]]
-python = ["3.12"]
-
-[tool.hatch.envs.lint]
-detached = true
-dependencies = ["ruff"]
-
-[tool.hatch.envs.lint.scripts]
-style = [
-  "ruff check --config .config/ruff.toml --diff {args:.}",
-  "ruff format --config .config/ruff.toml --diff {args:.}",
-]
+[tool.hatch.envs.hatch-static-analysis.scripts]
+format-check = ["ruff format --config .config/ruff.toml --check --diff {args:.}",]
+format-fix = ["ruff format --config .config/ruff.toml {args:.}",]
+lint-check = ["ruff check --config .config/ruff.toml {args:.}",]
+lint-fix = ["ruff check --config .config/ruff.toml --fix {args:.}",]

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/requirements.txt

@@ -1,57 +1,62 @@
 # This file was autogenerated by uv via the following command:
 #    uv pip compile pyproject.toml --resolver=backtracking --all-extras -o requirements.txt
-bcrypt==4.1.3
+bcrypt==4.2.0
     # via paramiko
-cffi==1.16.0
+cffi==1.17.0
     # via
     #   cryptography
     #   pynacl
 cfgv==3.4.0
     # via pre-commit
-coverage==7.5.1
+coverage==7.6.1
     # via pytest-cov
-cryptography==42.0.7
+cryptography==43.0.0
     # via paramiko
 distlib==0.3.8
     # via virtualenv
-filelock==3.14.0
+filelock==3.15.4
     # via virtualenv
 greenlet==3.0.3
     # via sqlalchemy
-identify==2.5.36
+identify==2.6.0
     # via pre-commit
 iniconfig==2.0.0
     # via pytest
-nodeenv==1.8.0
+nodeenv==1.9.1
     # via pre-commit
-packaging==24.0
+packaging==24.1
     # via pytest
 paramiko==3.4.0
     # via sshtunnel
-platformdirs==4.2.1
+platformdirs==4.2.2
     # via virtualenv
 pluggy==1.5.0
     # via pytest
-pre-commit==3.7.0
-psycopg==3.1.18
-psycopg-binary==3.1.18
+pre-commit==3.8.0
+    # via hdx-python-database (pyproject.toml)
+psycopg==3.2.1
+    # via hdx-python-database (pyproject.toml)
+psycopg-binary==3.2.1
     # via psycopg
 pycparser==2.22
     # via cffi
 pynacl==1.5.0
     # via paramiko
-pytest==8.2.0
-    # via pytest-cov
+pytest==8.3.2
+    # via
+    #   hdx-python-database (pyproject.toml)
+    #   pytest-cov
 pytest-cov==5.0.0
-pyyaml==6.0.1
+    # via hdx-python-database (pyproject.toml)
+pyyaml==6.0.2
     # via pre-commit
-setuptools==69.5.1
-    # via nodeenv
-sqlalchemy==2.0.30
+sqlalchemy==2.0.32
+    # via hdx-python-database (pyproject.toml)
 sshtunnel==0.4.0
-typing-extensions==4.11.0
+    # via hdx-python-database (pyproject.toml)
+typing-extensions==4.12.2
     # via
     #   psycopg
     #   sqlalchemy
-virtualenv==20.26.1
+virtualenv==20.26.3
     # via pre-commit

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/src/hdx/database/__init__.py

@@ -6,15 +6,14 @@ from typing import Any, Dict, List, Optional, Tuple, Type, Union
 from sqlalchemy import Engine, TableClause, create_engine
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.automap import automap_base
-from sqlalchemy.orm import DeclarativeBase, Session, sessionmaker
+from sqlalchemy.orm import DeclarativeBase, Session
 from sqlalchemy.pool import NullPool
 from sqlalchemy.sql.ddl import CreateSchema, DropSchema
-from sqlalchemy.util import Properties
 
 from ._version import version as __version__  # noqa: F401
 from .dburi import get_connection_uri
 from .no_timezone import Base as NoTZBase
-from .postgresql import wait_for_postgresql
+from .postgresql import restore_from_pgfile, wait_for_postgresql
 from .views import view
 from .with_timezone import Base as TZBase
 
@@ -41,6 +40,9 @@ class Database:
     with timezones to timezoneless database columns (but not when using
     reflection). If table_base is supplied, db_has_tz is ignored.
 
+    The database can be restored from a given pg_restore file supplied in the
+    parameter pg_restore_file.
+
     There is an option to wipe and create an empty schema in the database by
     setting recreate_schema to True and setting a schema_name ("public" is the
     default).
@@ -63,6 +65,7 @@ class Database:
         table_base (Optional[Type[DeclarativeBase]]): Override table base. Defaults to None.
         reflect (bool): Whether to reflect existing tables. Defaults to False.
         **kwargs: See below
+        pg_restore_file (str): Restore database from pg_restore file
         recreate_schema (bool): Whether to recreate schema
         schema_name (str): Database schema name. Defaults to "public".
         prepare_fn (Callable[[], None]]): Function to call before Base.metadata.create_all.
@@ -95,9 +98,11 @@ class Database:
             port = int(port)
         schema_name = None
         if len(kwargs) == 0:
+            pg_restore_file = None
             recreate_schema = False
             prepare_fn = do_nothing_fn
         else:
+            pg_restore_file = kwargs.pop("pg_restore_file", None)
             recreate_schema = kwargs.pop("recreate_schema", False)
             schema_name = kwargs.pop("schema", "public")
             prepare_fn = kwargs.pop("prepare_fn", do_nothing_fn)
@@ -144,6 +149,8 @@ class Database:
                 )
         if not engine and dialect == "postgresql":
             wait_for_postgresql(db_uri)
+        if pg_restore_file and db_uri:
+            restore_from_pgfile(db_uri, pg_restore_file)
         if not table_base:
             if db_has_tz:
                 table_base = TZBase
@@ -155,19 +162,31 @@ class Database:
         if recreate_schema:
             self.recreate_schema(engine, schema_name)
         self.prepare_results = prepare_fn()
-        self.session, self.reflected_classes = self.create_session(
+        self.session, self.base = self.create_session(
             engine,
             table_base=table_base,
             reflect=reflect,
         )
+        if reflect:
+            self.reflected_classes = self.base.classes
+        else:
+            self.reflected_classes = None
+
+    def cleanup(self) -> None:
+        self.base.metadata.clear()
+        self.session.close()
+        self.engine.dispose()
+        if self.server is not None:
+            self.server.stop()
 
     def __enter__(self) -> "Database":
         return self
 
     def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        self.session.close()
-        if self.server is not None:
-            self.server.stop()
+        self.cleanup()
+
+    def drop_all(self):
+        self.base.metadata.drop_all(self.engine)
 
     def get_engine(self) -> Engine:
         """Returns SQLAlchemy engine.
@@ -207,7 +226,7 @@ class Database:
         db_uri: Optional[str] = None,
         table_base: Type[DeclarativeBase] = NoTZBase,
         reflect: bool = False,
-    ) -> Tuple[Session, Optional[Properties]]:
+    ) -> Tuple[Session, Any]:
         """Creates SQLAlchemy session given SQLAlchemy engine or database uri
         (one of which must be supplied). Tables must inherit from Base in
         hdx.utilities.database unless base is defined. If reflect is True,
@@ -222,22 +241,19 @@ class Database:
             reflect (bool): Whether to reflect existing tables. Defaults to False.
 
         Returns:
-            Tuple[Session, Optional[Properties]]: (SQLAlchemy session, reflected classes if available)
+            Tuple[Session, Any]: (SQLAlchemy session, base)
         """
         if not engine:
             if db_uri is None:
                 raise DatabaseError("No engine or database uri provided!")
             engine = create_engine(db_uri, poolclass=NullPool, echo=False)
-        Session = sessionmaker(bind=engine)
         if reflect:
             Base = automap_base(declarative_base=table_base)
             Base.prepare(autoload_with=engine)
-            reflected_classes = Base.classes
+            table_base = Base
         else:
             table_base.metadata.create_all(engine)
-            reflected_classes = None
-        session = Session()
-        return session, reflected_classes
+        return Session(engine), table_base
 
     @staticmethod
     def recreate_schema(engine: Engine, schema_name: str = "public") -> bool:
@@ -285,6 +301,7 @@ class Database:
 
         Args:
             view_params_list (List[Dict]): List of dictionaries with view parameters
+
         Returns:
             List[TableClause]: SQLAlchemy Views
         """

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/src/hdx/database/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.3.1'
-__version_tuple__ = version_tuple = (1, 3, 1)
+__version__ = version = '1.3.2'
+__version_tuple__ = version_tuple = (1, 3, 2)

hdx_python_database-1.3.2/src/hdx/database/postgresql.py

@@ -0,0 +1,95 @@
+"""PostgreSQL specific utilities"""
+
+import logging
+import subprocess
+import time
+from os import environ
+
+from .dburi import get_params_from_connection_uri, remove_driver_from_uri
+
+try:
+    import psycopg
+except ImportError:
+    psycopg = None
+    # dependency missing, issue a warning
+    import warnings
+
+    warnings.warn(
+        "psycopg not found! Please install hdx-python-database[postgresql] to enable."
+    )
+
+logger = logging.getLogger(__name__)
+
+
+class PostgresError(Exception):
+    pass
+
+
+def wait_for_postgresql(db_uri: str) -> None:
+    """Waits for PostgreSQL database to be up
+
+    Args:
+        db_uri (str): Connection URI
+
+    Returns:
+        None
+    """
+    connecting_string = "Checking for PostgreSQL..."
+    db_uri_nd = remove_driver_from_uri(db_uri)
+    while True:
+        try:
+            logger.info(connecting_string)
+            connection = psycopg.connect(db_uri_nd, connect_timeout=3)
+            connection.close()
+            logger.info("PostgreSQL is running!")
+            break
+        except psycopg.OperationalError:
+            time.sleep(1)
+
+
+def restore_from_pgfile(db_uri: str, pg_restore_file: str) -> str:
+    """Restore database from a pg_restore file created by pg_backup using the
+    pg_restore command.
+
+    Args:
+        db_uri (str): Connection URI
+        pg_restore_file (str): Path to the pg_restore database file
+
+    Returns:
+        str: Output from the pg_restore command
+    """
+    db_params = get_params_from_connection_uri(db_uri)
+    subprocess_params = ["pg_restore", "-c"]
+    for key, value in db_params.items():
+        match key:
+            case "database":
+                subprocess_params.append("-d")
+            case "host":
+                subprocess_params.append("-h")
+            case "port":
+                subprocess_params.append("-p")
+            case "username":
+                subprocess_params.append("-U")
+            case _:
+                continue
+        subprocess_params.append(f"{value}")
+
+    subprocess_params.append(f"{pg_restore_file}")
+    env = environ.copy()
+    password = db_params.get("password")
+    if password:
+        env["PGPASSWORD"] = password
+    process = subprocess.run(
+        subprocess_params, env=env, capture_output=True, encoding="utf-8"
+    )
+    try:
+        process.check_returncode()
+    except subprocess.CalledProcessError as ex:
+        command = " ".join(subprocess_params)
+        raise PostgresError(
+            f"{command} failed. Return code: {process.returncode}"
+        ) from ex
+
+    for line in process.stdout.splitlines():
+        logger.info(line)
+    return process.stdout

{hdx_python_database-1.3.1 → hdx_python_database-1.3.2}/tests/hdx/database/conftest.py

@@ -1,3 +1,4 @@
+import subprocess
 from collections import namedtuple
 
 import psycopg
@@ -25,7 +26,11 @@ def mock_psycopg(monkeypatch):
             PsycopgConnection.connected = True
             raise psycopg.OperationalError
 
-    monkeypatch.setattr(psycopg, "connect", connect)
+    try:
+        monkeypatch.setattr(psycopg, "connect", connect)
+        yield
+    finally:
+        monkeypatch.delattr(psycopg, "connect")
 
 
 @pytest.fixture(scope="function")
@@ -39,12 +44,6 @@ def mock_SSHTunnelForwarder(monkeypatch):
     def stop(_):
         TestDatabase.stopped = True
 
-    monkeypatch.setattr(SSHTunnelForwarder, "__init__", init)
-    monkeypatch.setattr(SSHTunnelForwarder, "start", start)
-    monkeypatch.setattr(SSHTunnelForwarder, "stop", stop)
-    monkeypatch.setattr(SSHTunnelForwarder, "local_bind_host", "0.0.0.0")
-    monkeypatch.setattr(SSHTunnelForwarder, "local_bind_port", 12345)
-
     def create_session(_, engine, table_base, reflect):
         class Session:
             bind = namedtuple("Bind", "engine")
@@ -53,10 +52,23 @@ def mock_SSHTunnelForwarder(monkeypatch):
                 return None
 
         Session.bind.engine = engine
-        TestDatabase.table_base = table_base
-        return Session(), None
-
-    monkeypatch.setattr(Database, "create_session", create_session)
+        return Session(), table_base
+
+    try:
+        monkeypatch.setattr(SSHTunnelForwarder, "__init__", init)
+        monkeypatch.setattr(SSHTunnelForwarder, "start", start)
+        monkeypatch.setattr(SSHTunnelForwarder, "stop", stop)
+        monkeypatch.setattr(SSHTunnelForwarder, "local_bind_host", "0.0.0.0")
+        monkeypatch.setattr(SSHTunnelForwarder, "local_bind_port", 12345)
+        monkeypatch.setattr(Database, "create_session", create_session)
+        yield
+    finally:
+        monkeypatch.delattr(SSHTunnelForwarder, "__init__")
+        monkeypatch.delattr(SSHTunnelForwarder, "start")
+        monkeypatch.delattr(SSHTunnelForwarder, "stop")
+        monkeypatch.delattr(SSHTunnelForwarder, "local_bind_host")
+        monkeypatch.delattr(SSHTunnelForwarder, "local_bind_port")
+        monkeypatch.delattr(Database, "create_session")
 
 
 @pytest.fixture(scope="function")
@@ -84,3 +96,22 @@ def mock_engine():
             return SQAConnection()
 
     return MockEngine()
+
+
+@pytest.fixture(scope="function")
+def mock_subprocess(monkeypatch):
+    class CompletedProcess:
+        stdout = "WORKED!"
+
+        @staticmethod
+        def check_returncode():
+            return
+
+    def run(*args, **kwargs):
+        return CompletedProcess()
+
+    try:
+        monkeypatch.setattr(subprocess, "run", run)
+        yield
+    finally:
+        monkeypatch.delattr(subprocess, "run")

hdx_python_database-1.3.2/tests/hdx/database/test_database.py

@@ -0,0 +1,59 @@
+"""Database Utility Tests"""
+
+from datetime import datetime, timezone
+from os import remove
+from os.path import join
+
+import pytest
+from sqlalchemy import select
+
+from .dbtestdate import DBTestDate, date_view_params
+from hdx.database import Database, DatabaseError
+from hdx.database.no_timezone import Base as NoTZBase
+
+
+class TestDatabase:
+    dbpath = join("tests", "test_database.db")
+
+    @pytest.fixture(scope="function")
+    def nodatabase(self):
+        try:
+            remove(TestDatabase.dbpath)
+        except OSError:
+            pass
+        return f"sqlite:///{TestDatabase.dbpath}"
+
+    def test_get_session(self, nodatabase):
+        assert DBTestDate.__tablename__ == "db_test_date"
+
+        def prepare_fn():
+            return Database.prepare_views([date_view_params])
+
+        with Database(
+            database=TestDatabase.dbpath,
+            port=None,
+            dialect="sqlite",
+            prepare_fn=prepare_fn,
+        ) as dbdatabase:
+            dbsession = dbdatabase.get_session()
+            assert str(dbsession.bind.engine.url) == nodatabase
+            assert dbdatabase.base == NoTZBase
+            now = datetime(2022, 10, 20, 22, 35, 55, tzinfo=timezone.utc)
+            input_dbtestdate = DBTestDate()
+            input_dbtestdate.test_date = now
+            dbsession.add(input_dbtestdate)
+            dbsession.commit()
+            dbtestdate = dbsession.execute(select(DBTestDate)).scalar_one()
+            assert dbtestdate.test_date == now
+            date_view = dbdatabase.get_prepare_results()[0]
+            dbtestdate = dbsession.execute(select(date_view)).scalar_one()
+            assert dbtestdate == now
+            dbdatabase.drop_all()
+
+    def test_errors(self):
+        with pytest.raises(DatabaseError):
+            Database.create_session()
+
+        with pytest.raises(DatabaseError):
+            with Database():
+                pass

hdx_python_database-1.3.2/tests/hdx/database/test_postgresql.py

@@ -0,0 +1,30 @@
+"""PostgreSQL Utility Tests"""
+
+import pytest
+
+from . import PsycopgConnection
+from hdx.database.postgresql import (
+    PostgresError,
+    restore_from_pgfile,
+    wait_for_postgresql,
+)
+
+
+class TestPostgreSQL:
+    @pytest.fixture(scope="class")
+    def db_uri(self):
+        return "postgresql+psycopg://myuser:mypass@myserver:1234/mydatabase"
+
+    def test_wait_for_postgresql(self, db_uri, mock_psycopg):
+        PsycopgConnection.connected = False
+        wait_for_postgresql(db_uri)
+        assert PsycopgConnection.connected is True
+
+    def test_restore_from_pgfile(self, db_uri, mock_subprocess, mock_engine):
+        pg_restore_file = "test.pg_restore"
+        assert restore_from_pgfile(db_uri, pg_restore_file) == "WORKED!"
+
+    def test_restore_from_pgfile_raises(self, db_uri):
+        pg_restore_file = "NOT_EXIST.pg_restore"
+        with pytest.raises(PostgresError):
+            restore_from_pgfile(db_uri, pg_restore_file)

hdx_python_database-1.3.2/tests/hdx/database/test_recreate.py

@@ -0,0 +1,8 @@
+from hdx.database import Database
+
+
+def test_recreate_schema(mock_engine):
+    db_uri = "postgresql+psycopg://myuser:mypass@0.0.0.0:12345/mydatabase"
+    assert Database.recreate_schema(mock_engine, db_uri) is True
+    db_uri = "Error"
+    assert Database.recreate_schema(mock_engine, db_uri) is False

hdx_python_database-1.3.2/tests/hdx/database/test_reflect.py

@@ -0,0 +1,47 @@
+"""Database Utility Tests"""
+
+from datetime import datetime
+from os import remove
+from os.path import join
+from shutil import copyfile
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.orm.decl_api import DeclarativeAttributeIntercept
+
+from hdx.database import Database
+
+
+class TestReflect:
+    dbpath = join("tests", "test_database.db")
+    testdb = join("tests", "fixtures", "test.db")
+
+    @pytest.fixture(scope="function")
+    def database_to_reflect(self):
+        try:
+            remove(TestReflect.dbpath)
+            copyfile(TestReflect.testdb, TestReflect.dbpath)
+        except OSError:
+            pass
+        return f"sqlite:///{TestReflect.dbpath}"
+
+    def test_get_reflect_session(self, database_to_reflect):
+        with Database(
+            database=TestReflect.dbpath,
+            port=None,
+            dialect="sqlite",
+            reflect=True,
+        ) as dbdatabase:
+            dbengine = dbdatabase.get_engine()
+            assert str(dbengine.url) == "sqlite:///tests/test_database.db"
+            dbsession = dbdatabase.get_session()
+            assert isinstance(dbdatabase.base, DeclarativeAttributeIntercept)
+            assert str(dbsession.bind.engine.url) == database_to_reflect
+            Table1 = dbdatabase.get_reflected_classes().table1
+            row = dbsession.execute(select(Table1)).scalar_one()
+            assert row.id == "1"
+            assert row.col1 == "wfrefds"
+            # with reflection, type annotation maps do not work and hence
+            # we don't have a timezone here
+            assert row.date1 == datetime(1993, 9, 23, 14, 12, 56, 111000)
+            dbdatabase.drop_all()

hdx_python_database-1.3.2/tests/hdx/database/test_ssh.py

@@ -0,0 +1,80 @@
+"""Database Utility Tests"""
+
+from copy import deepcopy
+
+from hdx.database import Database
+from hdx.database.no_timezone import Base as NoTZBase
+from hdx.database.with_timezone import Base as TZBase
+
+
+class TestSSH:
+    params_pg = {
+        "database": "mydatabase",
+        "host": "myserver",
+        "port": 1234,
+        "username": "myuser",
+        "password": "mypass",
+        "dialect": "postgresql",
+        "driver": "psycopg",
+    }
+
+    def test_get_session_ssh(
+        self,
+        mock_psycopg,
+        mock_SSHTunnelForwarder,
+    ):
+        params = deepcopy(self.params_pg)
+        del params["password"]
+        with Database(
+            ssh_host="mysshhost", ssh_port=25, db_has_tz=True, **params
+        ) as dbdatabase:
+            dbsession = dbdatabase.get_session()
+            assert (
+                str(dbsession.bind.engine.url)
+                == "postgresql+psycopg://myuser@0.0.0.0:12345/mydatabase"
+            )
+            assert dbdatabase.base == TZBase
+            try:
+                dbdatabase.drop_all()
+            except AttributeError:
+                pass
+
+        with Database(
+            ssh_host="mysshhost", ssh_port=25, table_base=TZBase, **params
+        ) as dbdatabase:
+            dbsession = dbdatabase.get_session()
+            assert (
+                str(dbsession.bind.engine.url)
+                == "postgresql+psycopg://myuser@0.0.0.0:12345/mydatabase"
+            )
+            assert dbdatabase.base == TZBase
+            try:
+                dbdatabase.drop_all()
+            except AttributeError:
+                pass
+
+        with Database(ssh_host="mysshhost", **self.params_pg) as dbdatabase:
+            dbsession = dbdatabase.get_session()
+            assert (
+                str(dbsession.bind.engine.url)
+                == "postgresql+psycopg://myuser:***@0.0.0.0:12345/mydatabase"
+            )
+            assert dbdatabase.base == NoTZBase
+            try:
+                dbdatabase.drop_all()
+            except AttributeError:
+                pass
+
+        with Database(
+            ssh_host="mysshhost", ssh_port=25, **params
+        ) as dbdatabase:
+            dbsession = dbdatabase.get_session()
+            assert (
+                str(dbsession.bind.engine.url)
+                == "postgresql+psycopg://myuser@0.0.0.0:12345/mydatabase"
+            )
+            assert dbdatabase.base == NoTZBase
+            try:
+                dbdatabase.drop_all()
+            except AttributeError:
+                pass

hdx_python_database-1.3.1/src/hdx/database/postgresql.py

@@ -1,41 +0,0 @@
-"""PostgreSQL specific utilities"""
-
-import logging
-import time
-
-from .dburi import remove_driver_from_uri
-
-try:
-    import psycopg
-except ImportError:
-    psycopg = None
-    # dependency missing, issue a warning
-    import warnings
-
-    warnings.warn(
-        "psycopg not found! Please install hdx-python-database[postgresql] to enable."
-    )
-
-logger = logging.getLogger(__name__)
-
-
-def wait_for_postgresql(db_uri: str) -> None:
-    """Waits for PostgreSQL database to be up
-
-    Args:
-        db_uri (str): Connection URI
-
-    Returns:
-        None
-    """
-    connecting_string = "Checking for PostgreSQL..."
-    db_uri_nd = remove_driver_from_uri(db_uri)
-    while True:
-        try:
-            logger.info(connecting_string)
-            connection = psycopg.connect(db_uri_nd, connect_timeout=3)
-            connection.close()
-            logger.info("PostgreSQL is running!")
-            break
-        except psycopg.OperationalError:
-            time.sleep(1)

hdx_python_database-1.3.1/tests/hdx/database/test_database.py

@@ -1,149 +0,0 @@
-"""Database Utility Tests"""
-
-from copy import deepcopy
-from datetime import datetime, timezone
-from os import remove
-from os.path import join
-from shutil import copyfile
-
-import pytest
-from sqlalchemy import select
-
-from .dbtestdate import DBTestDate, date_view_params
-from hdx.database import Database, DatabaseError
-from hdx.database.no_timezone import Base as NoTZBase
-from hdx.database.with_timezone import Base as TZBase
-
-
-class TestDatabase:
-    started = False
-    stopped = False
-    table_base = NoTZBase
-    dbpath = join("tests", "test_database.db")
-    testdb = join("tests", "fixtures", "test.db")
-    params_pg = {
-        "database": "mydatabase",
-        "host": "myserver",
-        "port": 1234,
-        "username": "myuser",
-        "password": "mypass",
-        "dialect": "postgresql",
-        "driver": "psycopg",
-    }
-
-    @pytest.fixture(scope="function")
-    def nodatabase(self):
-        try:
-            remove(TestDatabase.dbpath)
-        except OSError:
-            pass
-        return f"sqlite:///{TestDatabase.dbpath}"
-
-    @pytest.fixture(scope="function")
-    def database_to_reflect(self):
-        try:
-            remove(TestDatabase.dbpath)
-            copyfile(TestDatabase.testdb, TestDatabase.dbpath)
-        except OSError:
-            pass
-        return f"sqlite:///{TestDatabase.dbpath}"
-
-    def test_get_session(self, nodatabase):
-        assert DBTestDate.__tablename__ == "db_test_date"
-
-        def prepare_fn():
-            return Database.prepare_views([date_view_params])
-
-        with Database(
-            database=TestDatabase.dbpath,
-            port=None,
-            dialect="sqlite",
-            prepare_fn=prepare_fn,
-        ) as dbdatabase:
-            dbsession = dbdatabase.session
-            assert str(dbsession.bind.engine.url) == nodatabase
-            assert TestDatabase.table_base == NoTZBase
-            now = datetime(2022, 10, 20, 22, 35, 55, tzinfo=timezone.utc)
-            input_dbtestdate = DBTestDate()
-            input_dbtestdate.test_date = now
-            dbsession.add(input_dbtestdate)
-            dbsession.commit()
-            dbtestdate = dbsession.execute(select(DBTestDate)).scalar_one()
-            assert dbtestdate.test_date == now
-            date_view = dbdatabase.get_prepare_results()[0]
-            dbtestdate = dbsession.execute(select(date_view)).scalar_one()
-            assert dbtestdate == now
-        with pytest.raises(DatabaseError):
-            Database.create_session()
-        with pytest.raises(DatabaseError):
-            with Database():
-                pass
-
-    def test_get_reflect_session(self, database_to_reflect):
-        with Database(
-            database=TestDatabase.dbpath,
-            port=None,
-            dialect="sqlite",
-            reflect=True,
-        ) as dbdatabase:
-            dbengine = dbdatabase.get_engine()
-            assert str(dbengine.url) == "sqlite:///tests/test_database.db"
-            dbsession = dbdatabase.get_session()
-            assert TestDatabase.table_base == NoTZBase
-            assert str(dbsession.bind.engine.url) == database_to_reflect
-            Table1 = dbdatabase.get_reflected_classes().table1
-            row = dbsession.execute(select(Table1)).scalar_one()
-            assert row.id == "1"
-            assert row.col1 == "wfrefds"
-            # with reflection, type annotation maps do not work and hence
-            # we don't have a timezone here
-            assert row.date1 == datetime(1993, 9, 23, 14, 12, 56, 111000)
-
-    def test_get_session_ssh(
-        self,
-        mock_psycopg,
-        mock_SSHTunnelForwarder,
-    ):
-        with Database(
-            ssh_host="mysshhost", **TestDatabase.params_pg
-        ) as dbdatabase:
-            dbsession = dbdatabase.get_session()
-            assert (
-                str(dbsession.bind.engine.url)
-                == "postgresql+psycopg://myuser:***@0.0.0.0:12345/mydatabase"
-            )
-        params = deepcopy(TestDatabase.params_pg)
-        del params["password"]
-        with Database(
-            ssh_host="mysshhost", ssh_port=25, **params
-        ) as dbdatabase:
-            dbsession = dbdatabase.get_session()
-            assert (
-                str(dbsession.bind.engine.url)
-                == "postgresql+psycopg://myuser@0.0.0.0:12345/mydatabase"
-            )
-        assert TestDatabase.table_base == NoTZBase
-        with Database(
-            ssh_host="mysshhost", ssh_port=25, db_has_tz=True, **params
-        ) as dbdatabase:
-            dbsession = dbdatabase.get_session()
-            assert (
-                str(dbsession.bind.engine.url)
-                == "postgresql+psycopg://myuser@0.0.0.0:12345/mydatabase"
-            )
-            assert TestDatabase.table_base == TZBase
-        with Database(
-            ssh_host="mysshhost", ssh_port=25, table_base=TZBase, **params
-        ) as dbdatabase:
-            dbsession = dbdatabase.get_session()
-            assert (
-                str(dbsession.bind.engine.url)
-                == "postgresql+psycopg://myuser@0.0.0.0:12345/mydatabase"
-            )
-            assert TestDatabase.table_base == TZBase
-
-    def test_recreate_schema(self, mock_engine):
-        db_uri = "postgresql+psycopg://myuser:mypass@0.0.0.0:12345/mydatabase"
-        assert Database.recreate_schema(mock_engine, db_uri) is True
-        db_uri = "Error"
-        assert Database.recreate_schema(mock_engine, db_uri) is False

hdx_python_database-1.3.1/tests/hdx/database/test_postgresql.py

@@ -1,15 +0,0 @@
-"""PostgreSQL Utility Tests"""
-
-from . import PsycopgConnection
-from hdx.database.postgresql import wait_for_postgresql
-
-
-class TestPostgreSQL:
-    connection_uri_pg = (
-        "postgresql+psycopg://myuser:mypass@myserver:1234/mydatabase"
-    )
-
-    def test_wait_for_postgresql(self, mock_psycopg):
-        PsycopgConnection.connected = False
-        wait_for_postgresql(TestPostgreSQL.connection_uri_pg)
-        assert PsycopgConnection.connected is True