hdx-python-database 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

hdx/database/__init__.py

@@ -1,322 +1,3 @@
-"""Database utilities"""
-
-import logging
-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
-from sqlalchemy.pool import NullPool
-from sqlalchemy.sql.ddl import CreateSchema, DropSchema
-
 from ._version import version as __version__  # noqa: F401
-from .dburi import get_connection_uri
-from .no_timezone import Base as NoTZBase
-from .postgresql import restore_from_pgfile, wait_for_postgresql
-from .views import view
-from .with_timezone import Base as TZBase
-
-logger = logging.getLogger(__name__)
-
-
-class DatabaseError(Exception):
-    pass
-
-
-def do_nothing_fn():
-    return None
-
-
-class Database:
-    """Database helper class to handle ssh tunnels, waiting for PostgreSQL to
-    be up etc. Can be used in a with statement returning a Database object that
-    if reflect is True will have a variable reflected_classes containing the
-    reflected classes. Either an SQLAlchemy engine, database uri or various
-    database parameters must be supplied.
-
-    db_has_tz which defaults to False indicates whether database datetime
-    columns have timezones. If not, conversion occurs between Python datetimes
-    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).
-
-    If a prepare function is supplied in prepare_fn, it will be executed before
-    Base.metadata.create_all and the results of it returned in instance variable
-    prepare_results.
-
-    Args:
-        engine (Optional[Engine]): SQLAlchemy engine to use.
-        db_uri (Optional[str]): Connection URI.
-        database (Optional[str]): Database name
-        host (Optional[str]): Host where database is located
-        port (Union[int, str, None]): Database port
-        username (Optional[str]): Username to log into database
-        password (Optional[str]): Password to log into database
-        dialect (str): Database dialect. Defaults to "postgresql".
-        driver (Optional[str]): Database driver. Defaults to None (psycopg if postgresql or None)
-        db_has_tz (bool): True if db datetime columns have timezone. Defaults to False.
-        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.
-        ssh_host (str): SSH host (the server to connect to)
-        ssh_port (int): SSH port. Defaults to 22.
-        ssh_username (str): SSH username
-        ssh_password (str): SSH password
-        ssh_private_key: Location of SSH private key (instead of ssh_password)
-        For more advanced usage, see SSHTunnelForwarder documentation.
-
-    """
-
-    def __init__(
-        self,
-        engine: Optional[Engine] = None,
-        db_uri: Optional[str] = None,
-        database: Optional[str] = None,
-        host: Optional[str] = None,
-        port: Union[int, str, None] = None,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        dialect: str = "postgresql",
-        driver: Optional[str] = None,
-        db_has_tz: bool = False,
-        table_base: Optional[Type[DeclarativeBase]] = None,
-        reflect: bool = False,
-        **kwargs: Any,
-    ) -> None:
-        if port is not None:
-            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)
-        if len(kwargs) != 0:
-            try:
-                import sshtunnel
-            except ImportError:
-                # dependency missing, log an error
-                logger.error(
-                    "sshtunnel not found! Please install hdx-python-database[sshtunnel] to enable."
-                )
-                raise
-            ssh_host = kwargs["ssh_host"]
-            del kwargs["ssh_host"]
-            ssh_port = kwargs.get("ssh_port")
-            if ssh_port is not None:
-                ssh_port = int(ssh_port)
-                del kwargs["ssh_port"]
-            else:
-                ssh_port = 22
-            self.server = sshtunnel.SSHTunnelForwarder(
-                (ssh_host, ssh_port),
-                remote_bind_address=(host, port),
-                **kwargs,
-            )
-            self.server.start()
-            host = self.server.local_bind_host
-            port = self.server.local_bind_port
-        else:
-            self.server = None
-        if not engine and not db_uri:
-            db_uri = get_connection_uri(
-                database,
-                host,
-                port,
-                username,
-                password,
-                dialect=dialect,
-                driver=driver,
-            )
-            if not db_uri:
-                raise DatabaseError(
-                    "No engine, database uri or connection parameters provided!"
-                )
-        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
-            else:
-                table_base = NoTZBase
-        if not engine:
-            engine = create_engine(db_uri, poolclass=NullPool, echo=False)
-        self.engine: Engine = engine
-        if recreate_schema:
-            self.recreate_schema(engine, schema_name)
-        self.prepare_results = prepare_fn()
-        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:
-        """Cleanup SQLAlchemy.
-
-        Returns:
-            sqlalchemy.Engine: SQLAlchemy engine
-        """
-        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.cleanup()
-
-    def drop_all(self) -> None:
-        """Drop all tables.
-
-        Returns:
-            None
-        """
-        self.base.metadata.drop_all(self.engine)
-
-    def get_engine(self) -> Engine:
-        """Returns SQLAlchemy engine.
-
-        Returns:
-            sqlalchemy.Engine: SQLAlchemy engine
-        """
-        return self.engine
-
-    def get_session(self) -> Session:
-        """Returns SQLAlchemy session.
-
-        Returns:
-            sqlalchemy.orm.Session: SQLAlchemy session
-        """
-        return self.session
-
-    def get_reflected_classes(self) -> Any:
-        """Gets reflected classes.
-
-        Returns:
-            Any: Reflected classes
-        """
-        return self.reflected_classes
-
-    def get_prepare_results(self) -> Any:
-        """Returns results from prepare function.
-
-        Returns:
-            Any: Results from prepare function
-        """
-        return self.prepare_results
-
-    @staticmethod
-    def create_session(
-        engine: Optional[Engine] = None,
-        db_uri: Optional[str] = None,
-        table_base: Type[DeclarativeBase] = NoTZBase,
-        reflect: bool = False,
-    ) -> 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,
-        classes will be reflected from an existing database and the reflected
-        classes will be returned. Note that type annotation maps don't work
-        with reflection.
-
-        Args:
-            engine (Optional[Engine]): SQLAlchemy engine to use. Defaults to None (create from db_uri).
-            db_uri (Optional[str]): Connection URI. Defaults to None (use engine).
-            table_base (Type[DeclarativeBase]): Base database table class. Defaults to NoTZBase.
-            reflect (bool): Whether to reflect existing tables. Defaults to False.
-
-        Returns:
-            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)
-        if reflect:
-            Base = automap_base(declarative_base=table_base)
-            Base.prepare(
-                autoload_with=engine, reflection_options={"views": True}
-            )
-            table_base = Base
-        else:
-            table_base.metadata.create_all(engine)
-        return Session(engine), table_base
-
-    @staticmethod
-    def recreate_schema(engine: Engine, schema_name: str = "public") -> bool:
-        """Wipe and create empty schema in database using SQLAlchemy.
-
-        Args:
-            engine (Engine): SQLAlchemy engine to use.
-            schema_name (str): Schema name. Defaults to "public".
-
-        Returns:
-            bool: True if all successful, False if not
-        """
-        # Wipe and create an empty schema
-        try:
-            with engine.connect() as connection:
-                connection.execute(
-                    DropSchema(schema_name, cascade=True, if_exists=True)
-                )
-                connection.commit()
-                connection.execute(
-                    CreateSchema(schema_name, if_not_exists=True)
-                )
-                connection.commit()
-                return True
-        except SQLAlchemyError:
-            return False
-
-    @staticmethod
-    def prepare_view(view_params: Dict) -> TableClause:
-        """Prepare SQLAlchemy view from dictionary with keys: name, metadata and
-        selectable. Must be run before Base.metadata.create_all.
-
-        Args:
-            view_params (Dict): Dictionary with keys name, metadata, selectable
-
-        Returns:
-            TableClause: SQLAlchemy View
-        """
-        return view(**view_params)
-
-    @classmethod
-    def prepare_views(cls, view_params_list: List[Dict]) -> List[TableClause]:
-        """Prepare SQLAlchemy views from a list of dictionaries with keys: name,
-        metadata and selectable. Must be run before Base.metadata.create_all.
-
-        Args:
-            view_params_list (List[Dict]): List of dictionaries with view parameters
-
-        Returns:
-            List[TableClause]: SQLAlchemy Views
-        """
-        results = []
-        for view_params in view_params_list:
-            results.append(cls.prepare_view(view_params))
-        return results
+from .database import Database as Database
+from .database import DatabaseError as DatabaseError

hdx/database/_version.py

@@ -1,8 +1,13 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -12,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.3.4'
-__version_tuple__ = version_tuple = (1, 3, 4)
+__version__ = version = '1.3.6'
+__version_tuple__ = version_tuple = (1, 3, 6)

hdx/database/database.py

@@ -0,0 +1,345 @@
+"""Database utilities"""
+
+import logging
+from typing import Any, Dict, List, Optional, Tuple, Type, Union
+
+from sqlalchemy import Engine, TableClause, create_engine, insert
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.ext.automap import automap_base
+from sqlalchemy.orm import DeclarativeBase, Session
+from sqlalchemy.pool import NullPool
+from sqlalchemy.sql.ddl import CreateSchema, DropSchema
+
+from .dburi import get_connection_uri
+from .no_timezone import Base as NoTZBase
+from .postgresql import restore_from_pgfile, wait_for_postgresql
+from .views import view
+from .with_timezone import Base as TZBase
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseError(Exception):
+    pass
+
+
+def do_nothing_fn():
+    return None
+
+
+class Database:
+    """Database helper class to handle ssh tunnels, waiting for PostgreSQL to
+    be up etc. Can be used in a with statement returning a Database object that
+    if reflect is True will have a variable reflected_classes containing the
+    reflected classes. Either an SQLAlchemy engine, database uri or various
+    database parameters must be supplied.
+
+    db_has_tz which defaults to False indicates whether database datetime
+    columns have timezones. If not, conversion occurs between Python datetimes
+    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).
+
+    If a prepare function is supplied in prepare_fn, it will be executed before
+    Base.metadata.create_all and the results of it returned in instance variable
+    prepare_results.
+
+    Args:
+        engine (Optional[Engine]): SQLAlchemy engine to use.
+        db_uri (Optional[str]): Connection URI.
+        database (Optional[str]): Database name
+        host (Optional[str]): Host where database is located
+        port (Union[int, str, None]): Database port
+        username (Optional[str]): Username to log into database
+        password (Optional[str]): Password to log into database
+        dialect (str): Database dialect. Defaults to "postgresql".
+        driver (Optional[str]): Database driver. Defaults to None (psycopg if postgresql or None)
+        db_has_tz (bool): True if db datetime columns have timezone. Defaults to False.
+        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.
+        ssh_host (str): SSH host (the server to connect to)
+        ssh_port (int): SSH port. Defaults to 22.
+        ssh_username (str): SSH username
+        ssh_password (str): SSH password
+        ssh_private_key: Location of SSH private key (instead of ssh_password)
+        For more advanced usage, see SSHTunnelForwarder documentation.
+
+    """
+
+    def __init__(
+        self,
+        engine: Optional[Engine] = None,
+        db_uri: Optional[str] = None,
+        database: Optional[str] = None,
+        host: Optional[str] = None,
+        port: Union[int, str, None] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        dialect: str = "postgresql",
+        driver: Optional[str] = None,
+        db_has_tz: bool = False,
+        table_base: Optional[Type[DeclarativeBase]] = None,
+        reflect: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        if port is not None:
+            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)
+        if len(kwargs) != 0:
+            try:
+                import sshtunnel
+            except ImportError:
+                # dependency missing, log an error
+                logger.error(
+                    "sshtunnel not found! Please install hdx-python-database[sshtunnel] to enable."
+                )
+                raise
+            ssh_host = kwargs["ssh_host"]
+            del kwargs["ssh_host"]
+            ssh_port = kwargs.get("ssh_port")
+            if ssh_port is not None:
+                ssh_port = int(ssh_port)
+                del kwargs["ssh_port"]
+            else:
+                ssh_port = 22
+            self._server = sshtunnel.SSHTunnelForwarder(
+                (ssh_host, ssh_port),
+                remote_bind_address=(host, port),
+                **kwargs,
+            )
+            self._server.start()
+            host = self._server.local_bind_host
+            port = self._server.local_bind_port
+        else:
+            self._server = None
+        if not engine and not db_uri:
+            db_uri = get_connection_uri(
+                database,
+                host,
+                port,
+                username,
+                password,
+                dialect=dialect,
+                driver=driver,
+            )
+            if not db_uri:
+                raise DatabaseError(
+                    "No engine, database uri or connection parameters provided!"
+                )
+        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
+            else:
+                table_base = NoTZBase
+        if not engine:
+            engine = create_engine(db_uri, poolclass=NullPool, echo=False)
+        self._engine: Engine = engine
+        if recreate_schema:
+            self.recreate_schema(engine, schema_name)
+        self._prepare_results = prepare_fn()
+        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:
+        """Cleanup SQLAlchemy.
+
+        Returns:
+            sqlalchemy.Engine: SQLAlchemy engine
+        """
+        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.cleanup()
+
+    def drop_all(self) -> None:
+        """Drop all tables.
+
+        Returns:
+            None
+        """
+        self._base.metadata.drop_all(self._engine)
+
+    def get_engine(self) -> Engine:
+        """Returns SQLAlchemy engine.
+
+        Returns:
+            sqlalchemy.Engine: SQLAlchemy engine
+        """
+        return self._engine
+
+    def get_session(self) -> Session:
+        """Returns SQLAlchemy session.
+
+        Returns:
+            sqlalchemy.orm.Session: SQLAlchemy session
+        """
+        return self._session
+
+    def get_reflected_classes(self) -> Any:
+        """Gets reflected classes.
+
+        Returns:
+            Any: Reflected classes
+        """
+        return self._reflected_classes
+
+    def get_prepare_results(self) -> Any:
+        """Returns results from prepare function.
+
+        Returns:
+            Any: Results from prepare function
+        """
+        return self._prepare_results
+
+    def batch_populate(
+        self,
+        rows: List[Dict],
+        dbtable: Type[DeclarativeBase],
+        batch_size: int = 1000,
+    ) -> None:
+        """Batch populate database table.
+
+        Args:
+            rows (List[Dict]): List of rows
+            dbtable (Type[DeclarativeBase]): Database table
+            batch_size (int): Batch size. Defaults to 1000.
+
+        Returns:
+            Tuple[Session, Any]: (SQLAlchemy session, base)
+        """
+        batches = range(len(rows) // batch_size + 1)
+        for batch in batches:
+            start_row = batch * batch_size
+            end_row = start_row + batch_size
+            batch_rows = rows[start_row:end_row]
+            self._session.execute(insert(dbtable), batch_rows)
+        self._session.commit()
+
+    @staticmethod
+    def create_session(
+        engine: Optional[Engine] = None,
+        db_uri: Optional[str] = None,
+        table_base: Type[DeclarativeBase] = NoTZBase,
+        reflect: bool = False,
+    ) -> 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,
+        classes will be reflected from an existing database and the reflected
+        classes will be returned. Note that type annotation maps don't work
+        with reflection.
+
+        Args:
+            engine (Optional[Engine]): SQLAlchemy engine to use. Defaults to None (create from db_uri).
+            db_uri (Optional[str]): Connection URI. Defaults to None (use engine).
+            table_base (Type[DeclarativeBase]): Base database table class. Defaults to NoTZBase.
+            reflect (bool): Whether to reflect existing tables. Defaults to False.
+
+        Returns:
+            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)
+        if reflect:
+            Base = automap_base(declarative_base=table_base)
+            Base.prepare(
+                autoload_with=engine, reflection_options={"views": True}
+            )
+            table_base = Base
+        else:
+            table_base.metadata.create_all(engine)
+        return Session(engine), table_base
+
+    @staticmethod
+    def recreate_schema(engine: Engine, schema_name: str = "public") -> bool:
+        """Wipe and create empty schema in database using SQLAlchemy.
+
+        Args:
+            engine (Engine): SQLAlchemy engine to use.
+            schema_name (str): Schema name. Defaults to "public".
+
+        Returns:
+            bool: True if all successful, False if not
+        """
+        # Wipe and create an empty schema
+        try:
+            with engine.connect() as connection:
+                connection.execute(
+                    DropSchema(schema_name, cascade=True, if_exists=True)
+                )
+                connection.commit()
+                connection.execute(
+                    CreateSchema(schema_name, if_not_exists=True)
+                )
+                connection.commit()
+                return True
+        except SQLAlchemyError:
+            return False
+
+    @staticmethod
+    def prepare_view(view_params: Dict) -> TableClause:
+        """Prepare SQLAlchemy view from dictionary with keys: name, metadata and
+        selectable. Must be run before Base.metadata.create_all.
+
+        Args:
+            view_params (Dict): Dictionary with keys name, metadata, selectable
+
+        Returns:
+            TableClause: SQLAlchemy View
+        """
+        return view(**view_params)
+
+    @classmethod
+    def prepare_views(cls, view_params_list: List[Dict]) -> List[TableClause]:
+        """Prepare SQLAlchemy views from a list of dictionaries with keys: name,
+        metadata and selectable. Must be run before Base.metadata.create_all.
+
+        Args:
+            view_params_list (List[Dict]): List of dictionaries with view parameters
+
+        Returns:
+            List[TableClause]: SQLAlchemy Views
+        """
+        results = []
+        for view_params in view_params_list:
+            results.append(cls.prepare_view(view_params))
+        return results

hdx/database/views.py

@@ -7,10 +7,8 @@ https://github.com/sqlalchemy/sqlalchemy/wiki/Views#sqlalchemy-14-20-version
 """
 
 import sqlalchemy as sa
-from sqlalchemy import MetaData, Selectable, TableClause
 from sqlalchemy.ext import compiler
 from sqlalchemy.schema import DDLElement
-from sqlalchemy.sql import table
 
 
 class CreateView(DDLElement):
@@ -45,22 +43,15 @@ def view_doesnt_exist(ddl, target, connection, **kw):
     return not view_exists(ddl, target, connection, **kw)
 
 
-def view(name: str, metadata: MetaData, selectable: Selectable) -> TableClause:
-    """Prepare SQLAlchemy view. Must be run before Base.metadata.create_all.
-
-    Args:
-        name (str): View name
-        metadata (MetaData): Base metadata
-        selectable (Selectable): SQLAlchemy select statement
-
-    Returns:
-        TableClause: SQLAlchemy View
-    """
-    t = table(name)
-
-    t._columns._populate_separate_keys(
-        col._make_proxy(t) for col in selectable.selected_columns
+def view(name, metadata, selectable):
+    t = sa.table(
+        name,
+        *(
+            sa.Column(c.name, c.type, primary_key=c.primary_key)
+            for c in selectable.selected_columns
+        ),
     )
+    t.primary_key.update(c for c in t.c if c.primary_key)
 
     sa.event.listen(
         metadata,

{hdx_python_database-1.3.4.dist-info → hdx_python_database-1.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: hdx-python-database
-Version: 1.3.4
+Version: 1.3.6
 Summary: HDX Python database utilities
 Project-URL: Homepage, https://github.com/OCHA-DAP/hdx-python-database
 Author-email: Michael Rans <rans@email.com>
@@ -28,6 +28,8 @@ Requires-Python: >=3.8
 Requires-Dist: sqlalchemy>=2
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkapi; extra == 'docs'
 Provides-Extra: postgresql
 Requires-Dist: psycopg[binary]; extra == 'postgresql'
 Provides-Extra: sshtunnel

hdx_python_database-1.3.6.dist-info/RECORD

@@ -0,0 +1,13 @@
+hdx/database/__init__.py,sha256=sG2OYV5LHskgiDkB4IeVeQyPHL22Ta1kuxf-xN92-5E,155
+hdx/database/_version.py,sha256=O6KrLlaUs-R3ppT6iunhqb7DyTGig2RAYgNqUiGEk0w,511
+hdx/database/database.py,sha256=hXjdRraeFouQ1afy9vHpCUkyaP-I2tPFGkDXE1z8A0A,12403
+hdx/database/dburi.py,sha256=rw8RuLpU85vxYl5-Zk1SdZRAz-tqre_ot5aEnkjhxAQ,2977
+hdx/database/no_timezone.py,sha256=Lw087G3qOf8H70o8Hq_VvOMZ3ANei-lIA_sUlpFU_Uo,1130
+hdx/database/postgresql.py,sha256=i5s_CJQZagMTuzgmnLakCOnSnvczpgJ26Q1CV6lz2_A,2646
+hdx/database/utils.py,sha256=6lLymWriMFCq8BZgrDt4V5z14GR3PbvG_WXZeBc99Ws,415
+hdx/database/views.py,sha256=U4BN9tbjlr93qKkeNbZNo_PCIwGsng09mQ2xFqh5CH0,1636
+hdx/database/with_timezone.py,sha256=GUUylmTwQHp22yedmCVKpVJzvjWgdS9lg9KeqciNJkY,235
+hdx_python_database-1.3.6.dist-info/METADATA,sha256=cPzaaLmmPam1abq5Ebh-Jed_qgv3jw-4FOnzLTc77f8,2750
+hdx_python_database-1.3.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hdx_python_database-1.3.6.dist-info/licenses/LICENSE,sha256=wc-4GpMn-ODs-U_bTe1YCiPVgvcjzrpYOx2wPuyAeII,1079
+hdx_python_database-1.3.6.dist-info/RECORD,,

{hdx_python_database-1.3.4.dist-info → hdx_python_database-1.3.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

hdx_python_database-1.3.4.dist-info/RECORD

@@ -1,12 +0,0 @@
-hdx/database/__init__.py,sha256=KS5VOdLv9P-YDTE_2ZUtVm6QNwezNpXMSd7SvMYU4EM,11655
-hdx/database/_version.py,sha256=q-rMkBhc2cbe8SdkcXn0kh8Fvtl2cIlapH0EvPC1bmc,411
-hdx/database/dburi.py,sha256=rw8RuLpU85vxYl5-Zk1SdZRAz-tqre_ot5aEnkjhxAQ,2977
-hdx/database/no_timezone.py,sha256=Lw087G3qOf8H70o8Hq_VvOMZ3ANei-lIA_sUlpFU_Uo,1130
-hdx/database/postgresql.py,sha256=i5s_CJQZagMTuzgmnLakCOnSnvczpgJ26Q1CV6lz2_A,2646
-hdx/database/utils.py,sha256=6lLymWriMFCq8BZgrDt4V5z14GR3PbvG_WXZeBc99Ws,415
-hdx/database/views.py,sha256=R_1Ni0U2CL3IlydxcB1vyZp7QoDZim6g-807jQIaWQU,1950
-hdx/database/with_timezone.py,sha256=GUUylmTwQHp22yedmCVKpVJzvjWgdS9lg9KeqciNJkY,235
-hdx_python_database-1.3.4.dist-info/METADATA,sha256=HjOmHAG50Rstq_1SbBcfg7rtjoPG64L2VHFRWZwYsMU,2691
-hdx_python_database-1.3.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-hdx_python_database-1.3.4.dist-info/licenses/LICENSE,sha256=wc-4GpMn-ODs-U_bTe1YCiPVgvcjzrpYOx2wPuyAeII,1079
-hdx_python_database-1.3.4.dist-info/RECORD,,