macrostrat.database 3.5.1__tar.gz → 3.5.3__tar.gz

{macrostrat_database-3.5.1 → macrostrat_database-3.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: macrostrat.database
-Version: 3.5.1
+Version: 3.5.3
 Summary: A SQLAlchemy-based database toolkit.
 Author: Daven Quinn
 Author-email: dev@davenquinn.com

{macrostrat_database-3.5.1 → macrostrat_database-3.5.3}/macrostrat/database/__init__.py

@@ -5,13 +5,14 @@ from typing import Optional, Union
 
 from psycopg2.errors import InvalidSavepointSpecification
 from psycopg2.sql import Identifier
-from sqlalchemy import URL, MetaData, create_engine, inspect, Engine
+from sqlalchemy import URL, Engine, MetaData, create_engine, inspect
 from sqlalchemy.exc import IntegrityError, InternalError
 from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.orm import Session, scoped_session, sessionmaker
 from sqlalchemy.sql.expression import Insert
 
 from macrostrat.utils import get_logger
+
 from .mapper import DatabaseMapper
 from .postgresql import on_conflict, prefix_inserts  # noqa
 from .utils import (  # noqa
@@ -184,6 +185,29 @@ class Database(object):
             self.__inspector__ = inspect(self.engine)
         return self.__inspector__
 
+    def refresh_schema(self, *, automap=None):
+        """
+        Refresh the current database connection
+
+        - closes the session and flushes
+        - removes the inspector
+
+        If automap is True, will automap the database after refreshing.
+        If automap is False, will not automap the database after refreshing.
+        If automap is None, it will re-map the database if it was previously mapped.
+        """
+        # Close the session
+        self.session.flush()
+        self.session.close()
+        # Remove the inspector
+        self.__inspector__ = None
+
+        if automap is None:
+            automap = self.mapper is not None
+
+        if automap:
+            self.automap()
+
     def entity_names(self, **kwargs):
         """
         Returns an iterator of names of *schema objects*

{macrostrat_database-3.5.1 → macrostrat_database-3.5.3}/macrostrat/database/transfer/dump_database.py

@@ -7,6 +7,7 @@ import aiofiles
 from sqlalchemy.engine import Engine
 
 from macrostrat.utils import get_logger
+
 from .stream_utils import print_stdout, print_stream_progress
 from .utils import _create_command
 

{macrostrat_database-3.5.1 → macrostrat_database-3.5.3}/macrostrat/database/transfer/move_tables.py

@@ -3,6 +3,7 @@ import asyncio
 from sqlalchemy.engine import Engine
 
 from macrostrat.utils import get_logger
+
 from .dump_database import pg_dump
 from .restore_database import pg_restore
 from .stream_utils import print_stdout, print_stream_progress

{macrostrat_database-3.5.1 → macrostrat_database-3.5.3}/macrostrat/database/transfer/restore_database.py

@@ -7,6 +7,7 @@ from rich.console import Console
 from sqlalchemy.engine import Engine
 
 from macrostrat.utils import get_logger
+
 from .stream_utils import print_stdout, print_stream_progress
 from .utils import _create_command, _create_database_if_not_exists
 

{macrostrat_database-3.5.1 → macrostrat_database-3.5.3}/macrostrat/database/transfer/stream_utils.py

@@ -5,6 +5,7 @@ import zlib
 from aiofiles.threadpool import AsyncBufferedIOBase
 
 from macrostrat.utils import get_logger
+
 from .utils import console
 
 log = get_logger(__name__)

{macrostrat_database-3.5.1 → macrostrat_database-3.5.3}/macrostrat/database/transfer/utils.py

@@ -5,7 +5,7 @@ from sqlalchemy.engine import Engine
 from sqlalchemy.engine.url import URL
 from sqlalchemy_utils import create_database, database_exists, drop_database
 
-from macrostrat.utils import get_logger, ApplicationError
+from macrostrat.utils import ApplicationError, get_logger
 
 console = Console()
 

{macrostrat_database-3.5.1 → macrostrat_database-3.5.3}/macrostrat/database/utils.py

@@ -1,6 +1,9 @@
+import os
 from contextlib import contextmanager
+from enum import Enum
 from pathlib import Path
 from re import search
+from sys import stderr
 from time import sleep
 from typing import IO, Union
 from warnings import warn
@@ -17,8 +20,8 @@ from sqlalchemy.exc import (
     IntegrityError,
     InternalError,
     InvalidRequestError,
-    ProgrammingError,
     OperationalError,
+    ProgrammingError,
 )
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy.schema import Table
@@ -46,23 +49,11 @@ def infer_is_sql_text(_string: str) -> bool:
     if isinstance(_string, bytes):
         _string = _string.decode("utf-8")
 
-    keywords = [
-        "SELECT",
-        "INSERT",
-        "UPDATE",
-        "CREATE",
-        "DROP",
-        "DELETE",
-        "ALTER",
-        "SET",
-        "GRANT",
-        "WITH",
-    ]
     lines = _string.split("\n")
     if len(lines) > 1:
         return True
     _string = _string.lower()
-    for i in keywords:
+    for i in _sql_keywords:
         if _string.strip().startswith(i.lower() + " "):
             return True
     return False
@@ -97,26 +88,35 @@ def get_dataframe(connectable, filename_or_query, **kwargs):
 
 
 def pretty_print(sql, **kwargs):
+    """Print and optionally summarize an SQL query"""
+    summarize = kwargs.pop("summarize", True)
+    if summarize:
+        sql = summarize_statement(sql)
+    secho(sql, **kwargs)
+
+
+_sql_keywords = [
+    "SELECT",
+    "INSERT",
+    "UPDATE",
+    "CREATE",
+    "DROP",
+    "DELETE",
+    "ALTER",
+    "SET",
+    "GRANT",
+    "WITH",
+    "NOTIFY",
+    "COPY",
+]
+
+
+def summarize_statement(sql):
     for line in sql.split("\n"):
-        for i in [
-            "SELECT",
-            "INSERT",
-            "UPDATE",
-            "CREATE",
-            "DROP",
-            "DELETE",
-            "ALTER",
-            "SET",
-            "GRANT",
-            "WITH",
-            "NOTIFY",
-            "COPY",
-        ]:
+        for i in _sql_keywords:
             if not line.startswith(i):
                 continue
-            start = line.split("(")[0].strip().rstrip(";").replace(" AS", "")
-            secho(start, **kwargs)
-            return
+            return line.split("(")[0].strip().rstrip(";").replace(" AS", "")
 
 
 def get_sql_text(sql, interpret_as_file=None, echo_file_name=True):
@@ -235,6 +235,25 @@ def infer_has_server_binds(sql):
 _default_statement_filter = lambda sql_text, params: True
 
 
+class OutputMode(Enum):
+    NONE = "none"
+    ERRORS = "errors"
+    SUMMARY = "summary"
+    ALL = "all"
+
+
+def _normalize_output_args(kwargs):
+    output_mode = kwargs.pop("output_mode", OutputMode.SUMMARY)
+    output_file = kwargs.pop("output_file", stderr)
+
+    if not isinstance(output_mode, OutputMode):
+        output_mode = OutputMode(output_mode)
+
+    if output_mode == OutputMode.NONE:
+        output_file = open(os.devnull, "w")
+    return output_mode, output_file
+
+
 def _run_sql(connectable, sql, params=None, **kwargs):
     """
     Internal function for running a query on a SQLAlchemy connectable,
@@ -251,6 +270,7 @@ def _run_sql(connectable, sql, params=None, **kwargs):
     has_server_binds = kwargs.pop("has_server_binds", None)
     ensure_single_query = kwargs.pop("ensure_single_query", False)
     statement_filter = kwargs.pop("statement_filter", _default_statement_filter)
+    output_mode, output_file = _normalize_output_args(kwargs)
 
     if stop_on_error:
         raise_errors = True
@@ -283,6 +303,7 @@ def _run_sql(connectable, sql, params=None, **kwargs):
             query = _render_query(query, connectable)
 
         sql_text = str(query)
+
         if isinstance(query, str):
             sql_text = format(query, strip_comments=True).strip()
             if sql_text == "":
@@ -293,8 +314,18 @@ def _run_sql(connectable, sql, params=None, **kwargs):
                 has_server_binds = infer_has_server_binds(sql_text)
 
         should_run = statement_filter(sql_text, params)
+
+        # Shorten summary text for printing
+        if output_mode != OutputMode.ALL:
+            sql_text = summarize_statement(sql_text)
+
         if not should_run:
-            pretty_print(sql_text, dim=True, strikethrough=True)
+            secho(
+                sql_text,
+                dim=True,
+                strikethrough=True,
+                file=output_file,
+            )
             continue
 
         # This only does something for postgresql, but it's harmless to run it for other engines
@@ -318,7 +349,7 @@ def _run_sql(connectable, sql, params=None, **kwargs):
                 trans.commit()
             elif hasattr(connectable, "commit"):
                 connectable.commit()
-            pretty_print(sql_text, dim=True)
+            secho(sql_text, dim=True, file=output_file)
         except Exception as err:
             if trans is not None:
                 trans.rollback()
@@ -327,7 +358,7 @@ def _run_sql(connectable, sql, params=None, **kwargs):
             if raise_errors or _should_raise_query_error(err):
                 raise err
 
-            _print_error(sql_text, err)
+            _print_error(sql_text, err, file=output_file)
         finally:
             set_wait_callback(None)
 
@@ -356,17 +387,18 @@ def _should_raise_query_error(err):
     return False
 
 
-def _print_error(sql_text, err):
+def _print_error(sql_text, err, **kwargs):
     if orig := getattr(err, "orig", None):
         _err = str(orig)
     else:
         _err = str(err)
     _err = _err.strip()
-    dim = "already exists" in _err
-    pretty_print(sql_text, fg=None if dim else "red", dim=True)
+    # Decide whether error should be dimmed
+    dim = kwargs.pop("dim", "already exists" in _err)
+    secho(sql_text, fg=None if dim else "red", dim=True, **kwargs)
     if dim:
         _err = "  " + _err
-    secho(_err, fg="red", dim=dim)
+    secho(_err, fg="red", dim=dim, **kwargs)
     log.error(err)
 
 
@@ -420,11 +452,17 @@ def run_fixtures(connectable, fixtures: Union[Path, list[Path]], params=None, **
     """
     recursive = kwargs.pop("recursive", False)
     order_by_name = kwargs.pop("order_by_name", True)
-    console = kwargs.pop("console", Console(stderr=True))
+    output_mode, output_file = _normalize_output_args(kwargs)
+
+    console = kwargs.pop("console", Console(stderr=True, file=output_file))
     files = get_sql_files(fixtures, recursive=recursive, order_by_name=order_by_name)
 
+    prefix = os.path.commonpath(files)
+
+    console.print(f"Running fixtures in [cyan bold]{prefix}[/]")
     for fixture in files:
-        console.print(f"[cyan bold]{fixture}[/]")
+        fn = fixture.relative_to(prefix)
+        console.print(f"[cyan bold]{fn}[/]")
         run_sql_file(connectable, fixture, params, **kwargs)
         console.print()
 
@@ -468,7 +506,9 @@ def run_sql(*args, **kwargs):
     return list(res)
 
 
-def execute(connectable, sql, params=None, stop_on_error=False):
+def execute(connectable, sql, params=None, stop_on_error=False, **kwargs):
+    output_file = kwargs.pop("output_file", None)
+    output_mode = kwargs.pop("output_mode", None)
     sql = format(sql, strip_comments=True).strip()
     if sql == "":
         return
@@ -477,17 +517,12 @@ def execute(connectable, sql, params=None, stop_on_error=False):
         res = connectable.execute(text(sql), params=params)
         if hasattr(connectable, "commit"):
             connectable.commit()
-        pretty_print(sql, dim=True)
+        pretty_print(sql, dim=True, file=output_file, mode=output_mode)
         return res
     except (ProgrammingError, IntegrityError) as err:
-        err = str(err.orig).strip()
-        dim = "already exists" in err
         if hasattr(connectable, "rollback"):
             connectable.rollback()
-        pretty_print(sql, fg=None if dim else "red", dim=True)
-        if dim:
-            err = "  " + err
-        secho(err, fg="red", dim=dim)
+        _print_error(sql, dim=True, file=output_file, mode=output_mode)
         if stop_on_error:
             return
     finally:

{macrostrat_database-3.5.1 → macrostrat_database-3.5.3}/pyproject.toml

@@ -3,7 +3,7 @@ authors = ["Daven Quinn <dev@davenquinn.com>"]
 description = "A SQLAlchemy-based database toolkit."
 name = "macrostrat.database"
 packages = [{ include = "macrostrat" }]
-version = "3.5.1"
+version = "3.5.3"
 
 [tool.poetry.dependencies]
 GeoAlchemy2 = "^0.15.2"