ul-db-utils 2.10.7__tar.gz

ul-db-utils-2.10.7/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.1
+Name: ul-db-utils
+Version: 2.10.7
+Summary: Python ul db utils
+Home-page: https://gitlab.neroelectronics.by/unic-lab/libraries/common-python-utils/db-utils.git
+Author: Unic-lab
+Author-email: 
+Platform: any
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Generic library db-utils
+
+> Provides common database-related functionality that can be used across different services.
+
+> Contains all database-related packages as dependencies.
+If you need to use some package that is not available in your service, you should add it here.
+
+## Common functionality
+> This section describes some classes or methods that are awailable for use in all services that use db-utils.
+
+### CustomQuery
+> As a default this class inherit from *flask_sqlalchemy BaseQuery* and adds additional filters.
+> 1. Filtering by only non-deleted (marked as *is_alive=True*) records.
+> 2. Joining with/without deleted (marked as *is_alive=False*) records.
+
+> If you want to add some additional by-default behavior to all services than you have to add it here.
+
+### transaction_commit
+> This context manager allows us to perform a database transaction at ORM level. You should use it like this:
+> ```python
+> with transaction_commit():
+>   query.perform(something)
+
+### Abstract models
+> This section describes all available abstract models from which we can inherit in our services.
+
+#### BaseModel
+```python
+class BaseModel(DbModel, SerializerMixin):
+
+    __abstract__ = True
+
+    query_class = CustomQuery
+
+    id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    date_created = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+    date_modified = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+    is_alive = db.Column(db.Boolean(), default=True, nullable=False)
+```
+> Provides UUID, record creation/modification datetime and is_alive field used for soft-deletion.
+
+#### BaseUndeletableModel
+```python
+class BaseUndeletableModel(DbModel, SerializerMixin):
+
+    __abstract__ = True
+
+    query_class = BaseQuery
+
+    id = db.Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    date_created = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+    date_modified = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+```
+> The same thing as BaseModel but models that will inherit from this model won't be able to soft-delete records.
+
+#### BaseMaterializedPGViewModel
+```python
+class BaseMaterializedPGView(DbModel, SerializerMixin):
+    id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    last_refresh_date = db.Column(db.DateTime(), nullable=False)
+
+    sql = ''
+    refresh_by_tables: List[str] = []
+
+    query_class = BaseQuery
+
+    __table_args__ = {'info': {'skip_autogenerate': True}}
+
+    _index_format = '{table}_{field}_index'
+    _pkey_format = '{table}_pkey'
+
+    __abstract__ = True
+```
+> Provides a way to create materialized views in PostgreSQL, add indexes, triggers, etc.
+
+#### BaseImmutableModel
+```python
+class BaseImmutableModel(DbModel, SerializerMixin):
+    __abstract__ = True
+
+    query_class = BaseQuery
+
+    id = db.Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    date_created = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+    user_created_id = db.Column(PG_UUID(as_uuid=True), nullable=False)
+```
+> Models that are going to inherit from this one won't have update record functionality.
+
+#### ApiUser
+```python
+class ApiUser(BaseModel):
+    __tablename__ = 'api_user'
+
+    date_expiration = db.Column(db.DateTime(), nullable=False)
+    name = db.Column(db.String(255), unique=True, nullable=False)
+    note = db.Column(db.Text(), nullable=False)
+    permissions = db.Column(ARRAY(db.Integer()), nullable=False)
+```
+> Every APIUser Model record has an array of permissions.
+
+
+### Exceptions
+
+| Exception                    | Desription                                                                                                                                    |
+|------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
+| ComparisonToNullError        | Raised when a client attempts to use a filter object that compares a resource's attribute to NULL using == operator instead of using is_null. |
+| DBFiltersError               | Raised when a client attempts to filter with invalid query params.                                                                            |
+| DBSortError                  | Raised when a client attempts to sort with invalid query params.                                                                              |
+| MultipleObjectsReturnedError | When only one object expected to be returned, but DB returned multiple objects.                                                               |
+| UnknownFieldError            | When user tries to reference the non-existent model field.                                                                                    |
+| DeletionNotAllowedError      | Raised when db obj deletion not allowed.                                                                                                      |
+| UpdateColumnNotAllowedError  | Raised when db table column update not allowed.                                                                                               |
+| UpdateNotAllowedError        | Raised when db table update not allowed.                                                                                                      |
+| DbError                      | Generic DB error.                                                                                                                             |
+
+
+## Adding new database-related package
+> First, try to understand why do you need this library and what exactly can you do with it. Look at the list of
+> already existing libraries and think if they can fulfill your needs. 
+
+> Check this library for deprecation, does it have enough maintenance, library dependencies.
+> If all above satisfies you, perform next steps:
+> 1. Add the package name and version to **Pipfile** under ```[packages]``` section. Example: ```alembic = "==1.8.1"```.
+> 2. Run ```pipenv install```.
+> 3. Add the package name and version to **setup.py** to ```install-requires``` section.
+> 4. Commit changes. ```git commit -m "Add dependency *library-name*"```.
+> 5. Run version patch: ```pipenv run version_patch```.
+> 6. Push changes directly to dev ```git push origin dev --tags``` or raise MR for your changes to be reviewed.

ul-db-utils-2.10.7/README.md

@@ -0,0 +1,128 @@
+# Generic library db-utils
+
+> Provides common database-related functionality that can be used across different services.
+
+> Contains all database-related packages as dependencies.
+If you need to use some package that is not available in your service, you should add it here.
+
+## Common functionality
+> This section describes some classes or methods that are awailable for use in all services that use db-utils.
+
+### CustomQuery
+> As a default this class inherit from *flask_sqlalchemy BaseQuery* and adds additional filters.
+> 1. Filtering by only non-deleted (marked as *is_alive=True*) records.
+> 2. Joining with/without deleted (marked as *is_alive=False*) records.
+
+> If you want to add some additional by-default behavior to all services than you have to add it here.
+
+### transaction_commit
+> This context manager allows us to perform a database transaction at ORM level. You should use it like this:
+> ```python
+> with transaction_commit():
+>   query.perform(something)
+
+### Abstract models
+> This section describes all available abstract models from which we can inherit in our services.
+
+#### BaseModel
+```python
+class BaseModel(DbModel, SerializerMixin):
+
+    __abstract__ = True
+
+    query_class = CustomQuery
+
+    id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    date_created = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+    date_modified = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+    is_alive = db.Column(db.Boolean(), default=True, nullable=False)
+```
+> Provides UUID, record creation/modification datetime and is_alive field used for soft-deletion.
+
+#### BaseUndeletableModel
+```python
+class BaseUndeletableModel(DbModel, SerializerMixin):
+
+    __abstract__ = True
+
+    query_class = BaseQuery
+
+    id = db.Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    date_created = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+    date_modified = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+```
+> The same thing as BaseModel but models that will inherit from this model won't be able to soft-delete records.
+
+#### BaseMaterializedPGViewModel
+```python
+class BaseMaterializedPGView(DbModel, SerializerMixin):
+    id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    last_refresh_date = db.Column(db.DateTime(), nullable=False)
+
+    sql = ''
+    refresh_by_tables: List[str] = []
+
+    query_class = BaseQuery
+
+    __table_args__ = {'info': {'skip_autogenerate': True}}
+
+    _index_format = '{table}_{field}_index'
+    _pkey_format = '{table}_pkey'
+
+    __abstract__ = True
+```
+> Provides a way to create materialized views in PostgreSQL, add indexes, triggers, etc.
+
+#### BaseImmutableModel
+```python
+class BaseImmutableModel(DbModel, SerializerMixin):
+    __abstract__ = True
+
+    query_class = BaseQuery
+
+    id = db.Column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    date_created = db.Column(db.DateTime(), default=datetime.utcnow(), nullable=False)
+    user_created_id = db.Column(PG_UUID(as_uuid=True), nullable=False)
+```
+> Models that are going to inherit from this one won't have update record functionality.
+
+#### ApiUser
+```python
+class ApiUser(BaseModel):
+    __tablename__ = 'api_user'
+
+    date_expiration = db.Column(db.DateTime(), nullable=False)
+    name = db.Column(db.String(255), unique=True, nullable=False)
+    note = db.Column(db.Text(), nullable=False)
+    permissions = db.Column(ARRAY(db.Integer()), nullable=False)
+```
+> Every APIUser Model record has an array of permissions.
+
+
+### Exceptions
+
+| Exception                    | Desription                                                                                                                                    |
+|------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
+| ComparisonToNullError        | Raised when a client attempts to use a filter object that compares a resource's attribute to NULL using == operator instead of using is_null. |
+| DBFiltersError               | Raised when a client attempts to filter with invalid query params.                                                                            |
+| DBSortError                  | Raised when a client attempts to sort with invalid query params.                                                                              |
+| MultipleObjectsReturnedError | When only one object expected to be returned, but DB returned multiple objects.                                                               |
+| UnknownFieldError            | When user tries to reference the non-existent model field.                                                                                    |
+| DeletionNotAllowedError      | Raised when db obj deletion not allowed.                                                                                                      |
+| UpdateColumnNotAllowedError  | Raised when db table column update not allowed.                                                                                               |
+| UpdateNotAllowedError        | Raised when db table update not allowed.                                                                                                      |
+| DbError                      | Generic DB error.                                                                                                                             |
+
+
+## Adding new database-related package
+> First, try to understand why do you need this library and what exactly can you do with it. Look at the list of
+> already existing libraries and think if they can fulfill your needs. 
+
+> Check this library for deprecation, does it have enough maintenance, library dependencies.
+> If all above satisfies you, perform next steps:
+> 1. Add the package name and version to **Pipfile** under ```[packages]``` section. Example: ```alembic = "==1.8.1"```.
+> 2. Run ```pipenv install```.
+> 3. Add the package name and version to **setup.py** to ```install-requires``` section.
+> 4. Commit changes. ```git commit -m "Add dependency *library-name*"```.
+> 5. Run version patch: ```pipenv run version_patch```.
+> 6. Push changes directly to dev ```git push origin dev --tags``` or raise MR for your changes to be reviewed.

ul-db-utils-2.10.7/setup.cfg

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

ul-db-utils-2.10.7/setup.py

@@ -0,0 +1,69 @@
+from os import path
+from setuptools import setup, find_packages
+
+HERE = path.abspath(path.dirname(__file__))
+
+with open(path.join(HERE, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+
+setup(
+    name='ul-db-utils',
+    version='2.10.7',
+    description='Python ul db utils',
+    author='Unic-lab',
+    author_email='',
+    url='https://gitlab.neroelectronics.by/unic-lab/libraries/common-python-utils/db-utils.git',
+    packages=find_packages(include=['ul_db_utils*']),
+    platforms='any',
+    package_data={
+        '': ['*.sql'],
+        'ul_db_utils': ['py.typed'],
+    },
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    classifiers=[
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Operating System :: OS Independent",
+    ],
+    entry_points={
+        "console_scripts": [
+            'uldbutls=ul_db_utils.main:main',
+        ],
+    },
+    include_package_data=True,
+    install_requires=[
+        "flask==2.1.3",  # FOR COMPATIBILITY
+        "py-dateutil==2.2",
+
+        "psycopg2-binary==2.9.5",
+        "flask-sqlalchemy==2.5.1",
+        "flask-migrate==3.1.0",
+        "sqlalchemy[mypy]==1.4.41",
+        "sqlalchemy-stubs==0.4",
+        "sqlalchemy-utils==0.38.3",
+        "sqlalchemy-serializer==1.4.1",
+        "alembic==1.8.1",
+        "mysql-connector-python==8.0.31",
+
+        "redis==4.3.4",
+
+        "types-psycopg2==2.9.18",
+        "sqlalchemy-stubs==0.4",
+        "types-flask-sqlalchemy==2.5.3",
+        "types-sqlalchemy-utils==1.0.1",
+        "types-sqlalchemy==1.4.40",
+        "types-redis==4.3.13",
+        "types-jinja2==2.11.9",
+        "types-python-dateutil==2.8.19",
+        # "types-requests==2.28.8",
+
+        "ul-py-tool==1.15.20",
+    ],
+)

ul-db-utils-2.10.7/ul_db_utils/commands/cmd_action.py

@@ -0,0 +1,37 @@
+import os
+import subprocess
+import sys
+from argparse import ArgumentParser
+from typing import Any
+
+from ul_py_tool.commands.cmd import Cmd
+
+
+class CmdAction(Cmd):
+    app_dir: str
+    app_migration_dir_name: str
+    app_file_name: str
+
+    @property
+    def app_rel_dir(self) -> str:
+        return os.path.relpath(self.app_dir, os.getcwd())
+
+    @staticmethod
+    def add_parser_args(parser: ArgumentParser) -> None:
+        parser.add_argument('--app-dir', dest='app_dir', type=str, required=True)
+        parser.add_argument('--app-migration-dir-name', dest='app_migration_dir_name', type=str, default='migrations', required=False)
+        parser.add_argument('--app-flask-file-name', dest='app_file_name', type=str, default='main.py', required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        migration_dir = os.path.join(self.app_dir, self.app_migration_dir_name)
+        flask_app_path = os.path.join(self.app_dir, self.app_file_name)
+        additional_args = ' '.join([f'{key}={value}' for key, value in kwargs.items()])
+
+        result = subprocess.run(
+            [f'FLASK_APP="{flask_app_path}" flask db {self.cmd} {additional_args} --directory "{migration_dir}"'],
+            shell=True,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        if result.returncode == 1:
+            exit(1)

ul-db-utils-2.10.7/ul_db_utils/commands/cmd_docs.py

@@ -0,0 +1,60 @@
+import argparse
+import os
+import re
+from contextlib import closing
+from typing import Any
+from urllib.parse import urlparse
+
+import psycopg2
+from pydantic import PostgresDsn
+from sqlalchemy import text
+from ul_py_tool.commands.cmd import Cmd
+
+
+class CmdDocs(Cmd):
+    uri: PostgresDsn
+    dest_path: str
+    schema_db: str
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        def_dir = os.path.join(os.getcwd(), 'docs/db')
+        parser.add_argument('--db-uri', dest='uri', type=str, required=True)
+        parser.add_argument('--dest', dest='dest_path', type=str, default=def_dir, required=False)
+        parser.add_argument('--schema_db', dest='schema_db', type=str, default='public', required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        parsed_db_uri = urlparse(self.uri)
+        db_name = parsed_db_uri.path.strip("/")
+        assert len(db_name) > 0
+
+        with open(os.path.join(os.path.dirname(__file__), 'doc_request_sql.sql'), 'rt') as sql_file:
+            doc_request_sql = sql_file.read()
+
+        doc_request_sql = text(doc_request_sql.format(  # type: ignore
+            schema_db=self.schema_db,
+        ))
+
+        with closing(psycopg2.connect(self.uri)) as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(str(doc_request_sql))
+                doc_data = cursor.fetchall()
+
+        for item in doc_data:
+            db_name = item[0]
+            schema_name = item[1]
+            table_name = item[2]
+            table_description = item[3]
+            file_path = os.path.join(self.dest_path, self.clean_slug(db_name), f"{self.clean_slug(schema_name)}__{self.clean_slug(table_name)}.md")
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            with open(file_path, "w+") as file:
+                file.write(f"# {db_name} \"{schema_name}.{table_name}\"\n\n"
+                           f"{table_description}\n\n"
+                           f"## Описание колонок\n\n"
+                           f"| Название | Тип | Описание |\n"
+                           f"| -------- | --- | -------- |\n")
+                for table_field_name, table_field_type, table_field_description in zip(item[4], item[5], item[6]):
+                    file.write(f"| {table_field_name} | {table_field_type} | {table_field_description} |\n")
+
+    def clean_slug(self, text: str) -> str:
+        return re.sub(r"[^\w\d]+", "_", text)

ul-db-utils-2.10.7/ul_db_utils/commands/cmd_dump.py

@@ -0,0 +1,42 @@
+import os
+import subprocess
+import sys
+from argparse import ArgumentParser
+from datetime import datetime
+from typing import Any
+from urllib.parse import urlparse
+
+from ul_py_tool.commands.cmd import Cmd
+
+
+class CmdDump(Cmd):
+    uri: str
+    dest_path: str
+
+    @staticmethod
+    def add_parser_args(parser: ArgumentParser) -> None:
+        def_file = os.path.join(os.getcwd(), '.tmp', f'dbdump_{datetime.now().isoformat()}.sql')
+        parser.add_argument('--db-uri', dest='uri', type=str, required=True)
+        parser.add_argument('--dest', dest='dest_path', type=str, default=def_file, required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        parsed_db_uri = urlparse(self.uri)
+        db_name = parsed_db_uri.path.strip("/")
+        assert len(db_name) > 0
+        os.makedirs(os.path.dirname(self.dest_path), exist_ok=True)
+        result = subprocess.run(
+            [(
+                f'PGPASSWORD={parsed_db_uri.password} pg_dump --schema=public --data-only -Fc '
+                f'-h {parsed_db_uri.hostname} '
+                f'-p {parsed_db_uri.port} '
+                f'-U {parsed_db_uri.username} '
+                f'-d {db_name} '
+                f'-f {self.dest_path} '
+            )],
+            shell=True,
+            check=True,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        if result.returncode == 1:
+            exit(1)

ul-db-utils-2.10.7/ul_db_utils/commands/cmd_restore.py

@@ -0,0 +1,109 @@
+import argparse
+import os
+import subprocess
+import sys
+from typing import Any
+from urllib.parse import urlparse
+
+from ul_py_tool.commands.cmd import Cmd
+
+
+class CmdRestore(Cmd):
+    uri: str
+    db_dump_file_path: str
+    flags: str
+    clean_data: int
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        db_dump_path = os.path.join(os.getcwd(), '.tmp', 'dbdump.sql')
+        parser.add_argument('--db-uri', dest='uri', type=str, required=True)
+        parser.add_argument('--dump-file', dest='db_dump_file_path', type=str, default=db_dump_path, required=False)
+        parser.add_argument('--clean-data', dest='clean_data', type=int, default=1, required=False)
+        parser.add_argument('--flags', dest='flags', type=str, default='', required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        parsed_db_uri = urlparse(self.uri)
+        db_name = parsed_db_uri.path.strip("/")
+        if not os.path.exists(self.db_dump_file_path):
+            raise ValueError(f'file {self.db_dump_file_path} was not found')
+
+        db_pref = f'-U {parsed_db_uri.username} -d {db_name} -h {parsed_db_uri.hostname} -p {parsed_db_uri.port}'
+        db_pwd = f'PGPASSWORD={parsed_db_uri.password}'
+
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create user replicator; "'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create user postgres;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create user viewer;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create schema audit;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create schema public;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "create schema cache;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        subprocess.run(
+            [f'{db_pwd} psql {db_pref} -c "drop extension timescaledb;"'],
+            shell=True,
+            check=False,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+
+        if self.clean_data:
+            truncate_all_sql = (
+                f"CREATE OR REPLACE FUNCTION truncate_tables(username IN VARCHAR) RETURNS void AS \\$$ "
+                f"DECLARE statements CURSOR FOR SELECT tablename FROM pg_tables WHERE tableowner = username AND schemaname = 'public'; "
+                f"BEGIN FOR stmt IN statements LOOP EXECUTE 'TRUNCATE TABLE ' || quote_ident(stmt.tablename) || ' CASCADE;'; END LOOP; END; "
+                f"\\$$ LANGUAGE plpgsql; "
+                f"SELECT truncate_tables('{parsed_db_uri.username}');"
+            )
+
+            subprocess.run(
+                [f'{db_pwd} psql {db_pref} -c "{truncate_all_sql}"'],
+                shell=True,
+                check=True,
+                stderr=sys.stderr,
+                stdout=sys.stdout,
+            )
+
+        result = subprocess.run(
+            [f'{db_pwd} pg_restore {db_pref} --data-only --exclude-schema=audit {self.flags} < "{self.db_dump_file_path}"'],
+            shell=True,
+            check=True,
+            stderr=sys.stderr,
+            stdout=sys.stdout,
+        )
+        if result.returncode == 1:
+            exit(1)

ul-db-utils-2.10.7/ul_db_utils/commands/cmd_waiting.py

@@ -0,0 +1,26 @@
+import argparse
+import logging
+from typing import Any
+
+from ul_py_tool.commands.cmd import Cmd
+
+from ul_db_utils.utils.waiting_for_postgres import waiting_for_postgres
+
+logger = logging.getLogger(__name__)
+
+
+class CmdWaiting(Cmd):
+    uri: str
+    max_times: int
+    delay: int
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('--db-uri', dest='uri', type=str, required=True)
+        parser.add_argument('--retry-times', dest='max_times', type=int, default=100, required=False)
+        parser.add_argument('--retry-delay-sec', dest='delay', type=int, default=1, required=False)
+
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        if not waiting_for_postgres(self.uri, retry_max_count=self.max_times, retry_delay_s=float(self.delay)):
+            exit(2)
+        exit(0)

ul-db-utils-2.10.7/ul_db_utils/commands/doc_request_sql.sql

@@ -0,0 +1,16 @@
+SELECT
+    current_database() as "db_name",
+    pgns.nspname as "schema_name",
+    tbl.relname as "table_name",
+    obj_description(tbl.oid, 'pg_class') as "table_description",
+    ARRAY_AGG(pgattr.attname) as "table_field_name",
+    ARRAY_AGG(pgtype.typname) as "table_field_type",
+    ARRAY_AGG(col_description(tbl.oid, pgattr.attnum)) as "table_field_description"
+FROM pg_class tbl
+    LEFT OUTER JOIN pg_catalog.pg_namespace pgns ON pgns.nspname = '{schema_db}'
+    LEFT OUTER JOIN pg_attribute pgattr ON pgattr.attrelid = tbl.oid AND pgattr.attnum > 0 AND pgattr.atttypid != 0
+    LEFT OUTER JOIN pg_type pgtype ON pgtype.oid = pgattr.atttypid
+    WHERE tbl.relnamespace = pgns.oid AND tbl.reltype != 0
+GROUP BY
+    db_name, schema_name, table_name, table_description
+ORDER BY table_name;

ul-db-utils-2.10.7/ul_db_utils/conf.py

@@ -0,0 +1,6 @@
+import os.path
+from typing import Optional
+
+THIS_LIBRARY_DIR = os.path.dirname(__file__)
+
+APPLICATION__DB_URI: Optional[str] = os.environ.get('APPLICATION__DB_URI', None)  # none only for backward compatibility

ul-db-utils-2.10.7/ul_db_utils/errors/compare_null_error.py

@@ -0,0 +1,9 @@
+from ul_db_utils.errors.db_error import DbError
+
+
+class ComparisonToNullError(DbError):
+    """Raised when a client attempts to use a filter object that compares a
+    resource's attribute to ``NULL`` using the ``==`` operator instead of using
+    ``is_null``.
+    """
+    pass