dsw-database 4.27.0__py3-none-any.whl

dsw/database/__init__.py

@@ -0,0 +1,4 @@
+from .database import Database
+
+
+__all__ = ['Database']

dsw/database/build_info.py

@@ -0,0 +1,17 @@
+# Generated file
+# - do not overwrite
+# - do not include in git
+from collections import namedtuple
+
+BuildInfo = namedtuple(
+    'BuildInfo',
+    ['version', 'built_at', 'sha', 'branch', 'tag'],
+)
+
+BUILD_INFO = BuildInfo(
+    version='v4.27.0~8ec71bd',
+    built_at='2026-02-03 08:44:49Z',
+    sha='8ec71bd85dfbea66adedb6590f7d76ae5143bbaa',
+    branch='HEAD',
+    tag='v4.27.0',
+)

dsw/database/database.py

@@ -0,0 +1,640 @@
+# pylint: disable=no-member
+import datetime
+import logging
+import typing
+
+import psycopg
+import psycopg.conninfo
+import psycopg.rows
+import psycopg.types.json
+import tenacity
+
+from dsw.config.model import DatabaseConfig
+
+from . import model
+
+
+LOG = logging.getLogger(__name__)
+
+RETRY_QUERY_MULTIPLIER = 0.5
+RETRY_QUERY_TRIES = 3
+
+RETRY_CONNECT_MULTIPLIER = 0.2
+RETRY_CONNECT_TRIES = 10
+
+
+def wrap_json_data(data: dict):
+    return psycopg.types.json.Json(data)
+
+
+# pylint: disable-next=too-many-public-methods
+class Database:
+
+    SELECT_DOCUMENT = ('SELECT * FROM document '
+                       'WHERE uuid = %s AND tenant_uuid = %s LIMIT 1;')
+    SELECT_DOCUMENTS = ('SELECT * FROM document '
+                        'WHERE project_uuid = %s AND tenant_uuid = %s;')
+    SELECT_DOCUMENT_SUBMISSIONS = ('SELECT * FROM submission '
+                                   'WHERE document_uuid = %s AND tenant_uuid = %s;')
+    SELECT_PROJECT_SUBMISSIONS = ('SELECT s.* '
+                                  'FROM document d JOIN submission s ON d.uuid = s.document_uuid '
+                                  'WHERE d.project_uuid = %s AND d.tenant_uuid = %s;')
+    SELECT_PROJECT_SIMPLE = ('SELECT p.* FROM project p '
+                             'WHERE p.uuid = %s AND p.tenant_uuid = %s;')
+    SELECT_TENANT_LIMIT = ('SELECT uuid, storage FROM tenant_limit_bundle '
+                           'WHERE uuid = %(tenant_uuid)s LIMIT 1;')
+    UPDATE_DOCUMENT_STATE = 'UPDATE document SET state = %s, worker_log = %s WHERE uuid = %s;'
+    UPDATE_DOCUMENT_RETRIEVED = 'UPDATE document SET retrieved_at = %s, state = %s WHERE uuid = %s;'
+    UPDATE_DOCUMENT_FINISHED = ('UPDATE document SET finished_at = %s, state = %s, '
+                                'file_name = %s, content_type = %s, worker_log = %s, '
+                                'file_size = %s WHERE uuid = %s;')
+    SELECT_TEMPLATE = ('SELECT * FROM document_template '
+                       'WHERE id = %s AND tenant_uuid = %s LIMIT 1;')
+    SELECT_TEMPLATE_FORMATS = ('SELECT * FROM document_template_format '
+                               'WHERE document_template_id = %s AND tenant_uuid = %s;')
+    SELECT_TEMPLATE_STEPS = ('SELECT * FROM document_template_format_step '
+                             'WHERE document_template_id = %s AND tenant_uuid = %s;')
+    SELECT_TEMPLATE_FILES = ('SELECT * FROM document_template_file '
+                             'WHERE document_template_id = %s AND tenant_uuid = %s;')
+    SELECT_TEMPLATE_ASSETS = ('SELECT * FROM document_template_asset '
+                              'WHERE document_template_id = %s AND tenant_uuid = %s;')
+    CHECK_TABLE_EXISTS = ('SELECT EXISTS(SELECT * FROM information_schema.tables'
+                          '                       WHERE table_name = %(table_name)s)')
+    SELECT_MAIL_CONFIG = ('SELECT * FROM instance_config_mail '
+                          'WHERE uuid = %(mail_config_uuid)s;')
+    UPDATE_COMPONENT_INFO = ('INSERT INTO component '
+                             '(name, version, built_at, created_at, updated_at) '
+                             'VALUES (%(name)s, %(version)s, %(built_at)s, '
+                             '%(created_at)s, %(updated_at)s)'
+                             'ON CONFLICT (name) DO '
+                             'UPDATE SET version = %(version)s, built_at = %(built_at)s, '
+                             'updated_at = %(updated_at)s;')
+    SELECT_COMPONENT_INFO = 'SELECT * FROM component WHERE name = %(name)s;'
+    SUM_FILE_SIZES = ('SELECT (SELECT COALESCE(SUM(file_size)::bigint, 0) '
+                      'FROM document WHERE tenant_uuid = %(tenant_uuid)s) '
+                      '+ (SELECT COALESCE(SUM(file_size)::bigint, 0) '
+                      'FROM document_template_asset WHERE tenant_uuid = %(tenant_uuid)s) '
+                      '+ (SELECT COALESCE(SUM(file_size)::bigint, 0) '
+                      'FROM project_file WHERE tenant_uuid = %(tenant_uuid)s) '
+                      'AS result;')
+    SELECT_USER = ('SELECT * FROM user_entity '
+                   'WHERE uuid = %(user_uuid)s AND tenant_uuid = %(tenant_uuid)s;')
+    SELECT_DEFAULT_LOCALE = ('SELECT * FROM locale '
+                             'WHERE default_locale IS TRUE AND '
+                             '  enabled is TRUE AND '
+                             '  tenant_uuid = %(tenant_uuid)s;')
+    SELECT_LOCALE = ('SELECT * FROM locale '
+                     'WHERE uuid = %(locale_uuid)s AND tenant_uuid = %(tenant_uuid)s;')
+
+    def __init__(self, cfg: DatabaseConfig, connect: bool = True,
+                 with_queue: bool = True):
+        self.cfg = cfg
+        LOG.info('Preparing PostgreSQL connection for QUERY')
+        self.conn_query = PostgresConnection(
+            name='query',
+            dsn=self.cfg.connection_string,
+            timeout=self.cfg.connection_timeout,
+            autocommit=False,
+        )
+        if connect:
+            self.conn_query.connect()
+        self.with_queue = with_queue
+        if with_queue:
+            LOG.info('Preparing PostgreSQL connection for QUEUE')
+            self.conn_queue = PostgresConnection(
+                name='queue',
+                dsn=self.cfg.connection_string,
+                timeout=self.cfg.connection_timeout,
+                autocommit=True,
+            )
+            if connect:
+                self.conn_queue.connect()
+
+    def connect(self):
+        self.conn_query.connect()
+        if self.with_queue:
+            self.conn_queue.connect()
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def _check_table_exists(self, table_name: str) -> bool:
+        with self.conn_query.new_cursor() as cursor:
+            try:
+                cursor.execute(
+                    query=self.CHECK_TABLE_EXISTS,
+                    params={'table_name': table_name},
+                )
+                return cursor.fetchone()[0]
+            except Exception:
+                return False
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def fetch_document(self, document_uuid: str, tenant_uuid: str) -> model.DBDocument | None:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(
+                query=self.SELECT_DOCUMENT,
+                params=(document_uuid, tenant_uuid),
+            )
+            result = cursor.fetchall()
+            if len(result) != 1:
+                return None
+            return model.DBDocument.from_dict_row(result[0])
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def fetch_tenant_limits(self, tenant_uuid: str) -> model.DBTenantLimits | None:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(
+                query=self.SELECT_TENANT_LIMIT,
+                params={'tenant_uuid': tenant_uuid},
+            )
+            result = cursor.fetchall()
+            if len(result) != 1:
+                return None
+            return model.DBTenantLimits.from_dict_row(result[0])
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def fetch_template(
+            self, template_id: str, tenant_uuid: str,
+    ) -> model.DBDocumentTemplate | None:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(
+                query=self.SELECT_TEMPLATE,
+                params=(template_id, tenant_uuid),
+            )
+            dt_result = cursor.fetchall()
+            if len(dt_result) != 1:
+                return None
+            template = model.DBDocumentTemplate.from_dict_row(dt_result[0])
+
+            cursor.execute(
+                query=self.SELECT_TEMPLATE_FORMATS,
+                params=(template_id, tenant_uuid),
+            )
+            formats_result = cursor.fetchall()
+            formats = sorted([
+                model.DBDocumentTemplateFormat.from_dict_row(x) for x in formats_result
+            ], key=lambda x: x.name)
+            cursor.execute(
+                query=self.SELECT_TEMPLATE_STEPS,
+                params=(template_id, tenant_uuid),
+            )
+            steps_result = cursor.fetchall()
+            steps = sorted([
+                model.DBDocumentTemplateStep.from_dict_row(x) for x in steps_result
+            ], key=lambda x: x.position)
+            steps_dict: dict[str, list[dict]] = {}
+            for step in steps:
+                if step.format_uuid not in steps_dict:
+                    steps_dict[step.format_uuid] = []
+                steps_dict[step.format_uuid].append({
+                    'name': step.name,
+                    'options': step.options,
+                })
+            for format_obj in formats:
+                template.formats.append({
+                    'uuid': format_obj.uuid,
+                    'name': format_obj.name,
+                    'steps': steps_dict.get(format_obj.uuid, []),
+                })
+        return template
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def fetch_template_files(
+            self, template_id: str, tenant_uuid: str,
+    ) -> list[model.DBDocumentTemplateFile]:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(
+                query=self.SELECT_TEMPLATE_FILES,
+                params=(template_id, tenant_uuid),
+            )
+            return [model.DBDocumentTemplateFile.from_dict_row(x) for x in cursor.fetchall()]
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def fetch_template_assets(
+            self, template_id: str, tenant_uuid: str,
+    ) -> list[model.DBDocumentTemplateAsset]:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(
+                query=self.SELECT_TEMPLATE_ASSETS,
+                params=(template_id, tenant_uuid),
+            )
+            return [model.DBDocumentTemplateAsset.from_dict_row(x) for x in cursor.fetchall()]
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def fetch_project_documents(self, project_uuid: str,
+                                tenant_uuid: str) -> list[model.DBDocument]:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(
+                query=self.SELECT_DOCUMENTS,
+                params=(project_uuid, tenant_uuid),
+            )
+            return [model.DBDocument.from_dict_row(x) for x in cursor.fetchall()]
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def fetch_document_submissions(self, document_uuid: str,
+                                   tenant_uuid: str) -> list[model.DBSubmission]:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(
+                query=self.SELECT_DOCUMENT_SUBMISSIONS,
+                params=(document_uuid, tenant_uuid),
+            )
+            return [model.DBSubmission.from_dict_row(x) for x in cursor.fetchall()]
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def fetch_project_submissions(self, project_uuid: str,
+                                  tenant_uuid: str) -> list[model.DBSubmission]:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(
+                query=self.SELECT_PROJECT_SUBMISSIONS,
+                params=(project_uuid, tenant_uuid),
+            )
+            return [model.DBSubmission.from_dict_row(x) for x in cursor.fetchall()]
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def fetch_project_simple(self, project_uuid: str,
+                             tenant_uuid: str) -> model.DBProjectSimple:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(
+                query=self.SELECT_PROJECT_SIMPLE,
+                params=(project_uuid, tenant_uuid),
+            )
+            return model.DBProjectSimple.from_dict_row(cursor.fetchone())
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def update_document_state(self, document_uuid: str, worker_log: str, state: str) -> bool:
+        with self.conn_query.new_cursor() as cursor:
+            cursor.execute(
+                query=self.UPDATE_DOCUMENT_STATE,
+                params=(state, worker_log, document_uuid),
+            )
+            return cursor.rowcount == 1
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def update_document_retrieved(self, retrieved_at: datetime.datetime,
+                                  document_uuid: str) -> bool:
+        with self.conn_query.new_cursor() as cursor:
+            cursor.execute(
+                query=self.UPDATE_DOCUMENT_RETRIEVED,
+                params=(
+                    retrieved_at,
+                    model.DocumentState.PROCESSING.value,
+                    document_uuid,
+                ),
+            )
+            return cursor.rowcount == 1
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def update_document_finished(
+            self, *, finished_at: datetime.datetime, file_name: str, file_size: int,
+            content_type: str, worker_log: str, document_uuid: str,
+    ) -> bool:
+        with self.conn_query.new_cursor() as cursor:
+            cursor.execute(
+                query=self.UPDATE_DOCUMENT_FINISHED,
+                params=(
+                    finished_at,
+                    model.DocumentState.FINISHED.value,
+                    file_name,
+                    content_type,
+                    worker_log,
+                    file_size,
+                    document_uuid,
+                ),
+            )
+            return cursor.rowcount == 1
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def get_currently_used_size(self, tenant_uuid: str):
+        with self.conn_query.new_cursor() as cursor:
+            cursor.execute(
+                query=self.SUM_FILE_SIZES,
+                params={'tenant_uuid': tenant_uuid},
+            )
+            row = cursor.fetchone()
+            return row[0]
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def get_mail_config(self, mail_config_uuid: str) -> model.DBInstanceConfigMail | None:
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            if not self._check_table_exists(table_name='instance_config_mail'):
+                return None
+            try:
+                cursor.execute(
+                    query=self.SELECT_MAIL_CONFIG,
+                    params={'mail_config_uuid': mail_config_uuid},
+                )
+                result = cursor.fetchone()
+                if result is None:
+                    return None
+                return model.DBInstanceConfigMail.from_dict_row(data=result)
+            except Exception as e:
+                LOG.warning('Could not retrieve instance_config_mail "%s": %s',
+                            mail_config_uuid, str(e))
+                return None
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def get_user(self, user_uuid: str, tenant_uuid: str) -> model.DBUserEntity | None:
+        if not self._check_table_exists(table_name='user_entity'):
+            return None
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            try:
+                cursor.execute(
+                    query=self.SELECT_USER,
+                    params={'user_uuid': user_uuid, 'tenant_uuid': tenant_uuid},
+                )
+                result = cursor.fetchone()
+                if result is None:
+                    return None
+                return model.DBUserEntity.from_dict_row(data=result)
+            except Exception as e:
+                LOG.warning('Could not retrieve user "%s" for tenant "%s": %s',
+                            user_uuid, tenant_uuid, str(e))
+                return None
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def get_default_locale(self, tenant_uuid: str) -> model.DBLocale | None:
+        if not self._check_table_exists(table_name='locale'):
+            return None
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            try:
+                cursor.execute(
+                    query=self.SELECT_DEFAULT_LOCALE,
+                    params={'tenant_uuid': tenant_uuid},
+                )
+                result = cursor.fetchone()
+                if result is None:
+                    return None
+                return model.DBLocale.from_dict_row(data=result)
+            except Exception as e:
+                LOG.warning('Could not retrieve default locale for tenant "%s": %s',
+                            tenant_uuid, str(e))
+                return None
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def get_locale(self, locale_uuid: str, tenant_uuid: str) -> model.DBLocale | None:
+        if not self._check_table_exists(table_name='locale'):
+            return None
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            try:
+                cursor.execute(
+                    query=self.SELECT_LOCALE,
+                    params={'locale_uuid': locale_uuid, 'tenant_uuid': tenant_uuid},
+                )
+                result = cursor.fetchone()
+                if result is None:
+                    return None
+                return model.DBLocale.from_dict_row(data=result)
+            except Exception as e:
+                LOG.warning('Could not retrieve locale "%s" for tenant "%s": %s',
+                            locale_uuid, tenant_uuid, str(e))
+                return None
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def update_component_info(self, name: str, version: str, built_at: datetime.datetime):
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            if not self._check_table_exists(table_name='component'):
+                return
+            ts_now = datetime.datetime.now(tz=datetime.UTC)
+            try:
+                cursor.execute(
+                    query=self.UPDATE_COMPONENT_INFO,
+                    params={
+                        'name': name,
+                        'version': version,
+                        'built_at': built_at,
+                        'created_at': ts_now,
+                        'updated_at': ts_now,
+                    },
+                )
+                self.conn_query.connection.commit()
+            except Exception as e:
+                LOG.warning('Could not update component info: %s', str(e))
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def get_component_info(self, name: str) -> model.DBComponent | None:
+        if not self._check_table_exists(table_name='component'):
+            return None
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            try:
+                cursor.execute(
+                    query=self.SELECT_COMPONENT_INFO,
+                    params={'name': name},
+                )
+                result = cursor.fetchone()
+                if result is None:
+                    return None
+                return model.DBComponent.from_dict_row(data=result)
+            except Exception as e:
+                LOG.warning('Could not get component info: %s', str(e))
+                return None
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def execute_queries(self, queries: typing.Iterable[str]):
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            for query in queries:
+                cursor.execute(query=query)
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_QUERY_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_QUERY_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def execute_query(self, query: str, **kwargs):
+        with self.conn_query.new_cursor(use_dict=True) as cursor:
+            cursor.execute(query=query, params=kwargs)
+
+
+class PostgresConnection:
+
+    def __init__(self, name: str, dsn: str, timeout=30000, autocommit=False):
+        self.name = name
+        self.listening = False
+        self.dsn = psycopg.conninfo.make_conninfo(
+            conninfo=dsn,
+            connect_timeout=timeout,
+        )
+        self.autocommit = autocommit
+        self._connection: psycopg.Connection | None = None
+
+    @tenacity.retry(
+        reraise=True,
+        wait=tenacity.wait_exponential(multiplier=RETRY_CONNECT_MULTIPLIER),
+        stop=tenacity.stop_after_attempt(RETRY_CONNECT_TRIES),
+        before=tenacity.before_log(LOG, logging.DEBUG),
+        after=tenacity.after_log(LOG, logging.DEBUG),
+    )
+    def _connect_db(self):
+        LOG.info('Creating connection to PostgreSQL database "%s"', self.name)
+        try:
+            connection: psycopg.Connection = psycopg.connect(
+                conninfo=self.dsn,
+                autocommit=self.autocommit,
+            )
+        except Exception as e:
+            LOG.error('Failed to connect to PostgreSQL database "%s": %s',
+                      self.name, str(e))
+            raise e
+        # test connection
+        cursor = connection.cursor()
+        cursor.execute(query='SELECT 1;')
+        result = cursor.fetchone()
+        if result is None:
+            raise RuntimeError('Failed to verify DB connection')
+        LOG.debug('DB connection verified (result=%s)', result[0])
+        cursor.close()
+        connection.commit()
+        self._connection = connection
+        self.listening = False
+
+    def connect(self):
+        if not self._connection or self._connection.closed != 0:
+            self._connect_db()
+
+    @property
+    def connection(self) -> psycopg.Connection:
+        self.connect()
+        if not self._connection:
+            raise RuntimeError('Connection is not established')
+        return self._connection
+
+    def new_cursor(self, use_dict: bool = False):
+        return self.connection.cursor(
+            row_factory=psycopg.rows.dict_row if use_dict else psycopg.rows.tuple_row,
+        )
+
+    def reset(self):
+        self.close()
+        self.connect()
+
+    def close(self):
+        if self._connection:
+            LOG.info('Closing connection to PostgreSQL database "%s"', self.name)
+            self._connection.close()
+        self._connection = None

dsw/database/model.py

@@ -0,0 +1,478 @@
+import dataclasses
+import datetime
+import enum
+import json
+
+
+NULL_UUID = '00000000-0000-0000-0000-000000000000'
+
+
+class DocumentState(enum.Enum):
+    QUEUED = 'QueuedDocumentState'
+    PROCESSING = 'InProgressDocumentState'
+    FAILED = 'ErrorDocumentState'
+    FINISHED = 'DoneDocumentState'
+
+
+class DocumentTemplatePhase(enum.Enum):
+    RELEASED = 'ReleasedTemplatePhase'
+    DEPRECATED = 'DeprecatedTemplatePhase'
+    DRAFT = 'DraftTemplatePhase'
+
+
+@dataclasses.dataclass
+class DBComponent:
+    name: str
+    version: str
+    built_at: datetime.datetime
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+
+    @staticmethod
+    def from_dict_row(data: dict):
+        return DBComponent(
+            name=data['name'],
+            version=data['version'],
+            built_at=data['built_at'],
+            created_at=data['created_at'],
+            updated_at=data['updated_at'],
+        )
+
+
+@dataclasses.dataclass
+class DBDocument:
+    uuid: str
+    name: str
+    state: str
+    durability: str
+    project_uuid: str | None
+    project_event_uuid: str | None
+    project_replies_hash: str
+    document_template_id: str
+    format_uuid: str
+    file_name: str
+    content_type: str
+    worker_log: str
+    created_by: str
+    retrieved_at: datetime.datetime | None
+    finished_at: datetime.datetime | None
+    created_at: datetime.datetime
+    tenant_uuid: str
+    file_size: int
+
+    @staticmethod
+    def from_dict_row(data: dict):
+        project_uuid = data['project_uuid']
+        event_uuid = data['project_event_uuid']
+        return DBDocument(
+            uuid=str(data['uuid']),
+            name=data['name'],
+            state=data['state'],
+            durability=data['durability'],
+            project_uuid=str(project_uuid) if project_uuid else None,
+            project_event_uuid=str(event_uuid) if event_uuid else None,
+            project_replies_hash=data['project_replies_hash'],
+            document_template_id=data['document_template_id'],
+            format_uuid=str(data['format_uuid']),
+            created_by=str(data['created_by']),
+            retrieved_at=data['retrieved_at'],
+            finished_at=data['finished_at'],
+            created_at=data['created_at'],
+            file_name=data['file_name'],
+            content_type=data['content_type'],
+            worker_log=data['worker_log'],
+            tenant_uuid=str(data.get('tenant_uuid', NULL_UUID)),
+            file_size=data['file_size'],
+        )
+
+
+@dataclasses.dataclass
+class DBDocumentTemplate:
+    id: str
+    name: str
+    organization_id: str
+    template_id: str
+    version: str
+    metamodel_version: int
+    description: str
+    readme: str
+    license: str
+    allowed_packages: dict
+    formats: list
+    phase: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    tenant_uuid: str
+
+    @property
+    def is_draft(self):
+        return self.phase == DocumentTemplatePhase.DRAFT
+
+    @property
+    def is_released(self):
+        return self.phase == DocumentTemplatePhase.RELEASED
+
+    @property
+    def is_deprecated(self):
+        return self.phase == DocumentTemplatePhase.DEPRECATED
+
+    @staticmethod
+    def from_dict_row(data: dict) -> 'DBDocumentTemplate':
+        return DBDocumentTemplate(
+            id=data['id'],
+            name=data['name'],
+            organization_id=data['organization_id'],
+            template_id=data['template_id'],
+            version=data['version'],
+            metamodel_version=data['metamodel_version'],
+            description=data['description'],
+            readme=data['readme'],
+            license=data['license'],
+            allowed_packages=data['allowed_packages'],
+            formats=[],
+            phase=data['phase'],
+            created_at=data['created_at'],
+            updated_at=data['updated_at'],
+            tenant_uuid=str(data.get('tenant_uuid', NULL_UUID)),
+        )
+
+
+@dataclasses.dataclass
+class DBDocumentTemplateFormat:
+    document_template_id: str
+    uuid: str
+    name: str
+    icon: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    tenant_uuid: str
+
+    @staticmethod
+    def from_dict_row(data: dict) -> 'DBDocumentTemplateFormat':
+        return DBDocumentTemplateFormat(
+            document_template_id=data['document_template_id'],
+            uuid=str(data['uuid']),
+            name=data['name'],
+            icon=data['icon'],
+            created_at=data['created_at'],
+            updated_at=data['updated_at'],
+            tenant_uuid=str(data.get('tenant_uuid', NULL_UUID)),
+        )
+
+
+@dataclasses.dataclass
+class DBDocumentTemplateStep:
+    document_template_id: str
+    format_uuid: str
+    position: int
+    name: str
+    options: dict[str, str]
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    tenant_uuid: str
+
+    @staticmethod
+    def from_dict_row(data: dict) -> 'DBDocumentTemplateStep':
+        return DBDocumentTemplateStep(
+            document_template_id=data['document_template_id'],
+            format_uuid=str(data['format_uuid']),
+            position=data['position'],
+            name=data['name'],
+            options=data['options'],
+            created_at=data['created_at'],
+            updated_at=data['updated_at'],
+            tenant_uuid=str(data.get('tenant_uuid', NULL_UUID)),
+        )
+
+
+@dataclasses.dataclass
+class DBDocumentTemplateFile:
+    document_template_id: str
+    uuid: str
+    file_name: str
+    content: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    tenant_uuid: str
+
+    @staticmethod
+    def from_dict_row(data: dict) -> 'DBDocumentTemplateFile':
+        return DBDocumentTemplateFile(
+            document_template_id=data['document_template_id'],
+            uuid=str(data['uuid']),
+            file_name=data['file_name'],
+            content=data['content'],
+            created_at=data['created_at'],
+            updated_at=data['updated_at'],
+            tenant_uuid=str(data.get('tenant_uuid', NULL_UUID)),
+        )
+
+
+@dataclasses.dataclass
+class DBDocumentTemplateAsset:
+    document_template_id: str
+    uuid: str
+    file_name: str
+    content_type: str
+    file_size: int
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    tenant_uuid: str
+
+    @staticmethod
+    def from_dict_row(data: dict) -> 'DBDocumentTemplateAsset':
+        return DBDocumentTemplateAsset(
+            document_template_id=data['document_template_id'],
+            uuid=str(data['uuid']),
+            file_name=data['file_name'],
+            content_type=data['content_type'],
+            file_size=data['file_size'],
+            created_at=data['created_at'],
+            updated_at=data['updated_at'],
+            tenant_uuid=str(data.get('tenant_uuid', NULL_UUID)),
+        )
+
+
+@dataclasses.dataclass
+class PersistentCommand:
+    uuid: str
+    state: str
+    component: str
+    function: str
+    body: dict
+    last_error_message: str | None
+    attempts: int
+    max_attempts: int
+    tenant_uuid: str
+    created_by: str | None
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+
+    @staticmethod
+    def from_dict_row(data: dict):
+        return PersistentCommand(
+            uuid=str(data['uuid']),
+            state=data['state'],
+            component=data['component'],
+            function=data['function'],
+            body=json.loads(data['body']),
+            last_error_message=data['last_error_message'],
+            attempts=data['attempts'],
+            max_attempts=data['max_attempts'],
+            created_by=str(data['created_by']),
+            created_at=data['created_at'],
+            updated_at=data['updated_at'],
+            tenant_uuid=str(data.get('tenant_uuid', NULL_UUID)),
+        )
+
+
+@dataclasses.dataclass
+class DBTenantLimits:
+    tenant_uuid: str
+    storage: int | None
+
+    @staticmethod
+    def from_dict_row(data: dict):
+        return DBTenantLimits(
+            tenant_uuid=str(data['uuid']),
+            storage=data['storage'],
+        )
+
+
+@dataclasses.dataclass
+class DBSubmission:
+    TABLE_NAME = 'submission'
+
+    uuid: str
+    state: str
+    location: str
+    returned_data: str
+    service_id: str
+    document_uuid: str
+    created_by: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    tenant_uuid: str
+
+    @staticmethod
+    def from_dict_row(data: dict):
+        return DBSubmission(
+            uuid=str(data['uuid']),
+            state=data['state'],
+            location=data['location'],
+            returned_data=data['returned_data'],
+            service_id=data['service_id'],
+            document_uuid=str(data['document_uuid']),
+            created_by=str(data['created_by']),
+            created_at=data['created_at'],
+            updated_at=data['updated_at'],
+            tenant_uuid=str(data.get('tenant_uuid', NULL_UUID)),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            'uuid': self.uuid,
+            'state': self.state,
+            'location': self.location,
+            'returned_data': self.returned_data,
+            'service_id': self.service_id,
+            'document_uuid': self.document_uuid,
+            'created_by': self.created_by,
+            'created_at': self.created_at.isoformat(timespec='milliseconds'),
+            'updated_at': self.updated_at.isoformat(timespec='milliseconds'),
+            'tenant_uuid': self.tenant_uuid,
+        }
+
+
+@dataclasses.dataclass
+class DBProjectSimple:
+    # without: events, answered_questions, unanswered_questions,
+    #          squashed, versions, selected_question_tag_uuids
+    TABLE_NAME = 'project'
+
+    uuid: str
+    name: str
+    visibility: str
+    sharing: str
+    package_id: str
+    document_template_id: str
+    format_uuid: str
+    created_by: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    description: str
+    is_template: bool
+    project_tags: list[str]
+    tenant_uuid: str
+
+    @staticmethod
+    def from_dict_row(data: dict):
+        return DBProjectSimple(
+            uuid=str(data['uuid']),
+            name=data['name'],
+            visibility=data['visibility'],
+            sharing=data['sharing'],
+            package_id=data['package_id'],
+            document_template_id=data['document_template_id'],
+            format_uuid=str(data['format_uuid']),
+            created_by=str(data['created_by']),
+            created_at=data['created_at'],
+            updated_at=data['updated_at'],
+            description=data['description'],
+            is_template=data['is_template'],
+            project_tags=data['project_tags'],
+            tenant_uuid=str(data.get('tenant_uuid', NULL_UUID)),
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            'uuid': self.uuid,
+            'name': self.name,
+            'visibility': self.visibility,
+            'sharing': self.sharing,
+            'package_id': self.package_id,
+            'document_template_id': self.document_template_id,
+            'format_uuid': self.format_uuid,
+            'created_by': self.created_by,
+            'created_at': self.created_at.isoformat(timespec='milliseconds'),
+            'updated_at': self.updated_at.isoformat(timespec='milliseconds'),
+            'description': self.description,
+            'is_template': self.is_template,
+            'project_tags': self.project_tags,
+            'tenant_uuid': self.tenant_uuid,
+        }
+
+
+@dataclasses.dataclass
+class DBUserEntity:
+    TABLE_NAME = 'user_entity'
+
+    uuid: str
+    first_name: str
+    last_name: str
+    email: str
+    locale: str | None
+
+    @staticmethod
+    def from_dict_row(data: dict):
+        return DBUserEntity(
+            uuid=str(data['uuid']),
+            first_name=data['first_name'],
+            last_name=data['last_name'],
+            email=data['email'],
+            locale=data['locale'],
+        )
+
+
+@dataclasses.dataclass
+class DBLocale:
+    TABLE_NAME = 'locale'
+
+    uuid: str
+    organization_id: str
+    locale_id: str
+    version: str
+    name: str
+    code: str
+    default_locale: bool
+    enabled: bool
+
+    @staticmethod
+    def from_dict_row(data: dict):
+        return DBLocale(
+            uuid=str(data['uuid']),
+            organization_id=data['organization_id'],
+            locale_id=data['locale_id'],
+            version=data['version'],
+            name=data['name'],
+            code=data['code'],
+            default_locale=data['default_locale'],
+            enabled=data['enabled'],
+        )
+
+    @property
+    def id(self) -> str:
+        return f'{self.organization_id}:{self.locale_id}:{self.version}'
+
+
+@dataclasses.dataclass
+class DBInstanceConfigMail:
+    TABLE_NAME = 'instance_config_mail'
+
+    uuid: str
+    enabled: bool
+    provider: str
+    sender_name: str | None
+    sender_email: str | None
+    smtp_host: str | None
+    smtp_port: int | None
+    smtp_security: str | None
+    smtp_username: str | None
+    smtp_password: str | None
+    aws_access_key_id: str | None
+    aws_secret_access_key: str | None
+    aws_region: str | None
+    rate_limit_window: int | None
+    rate_limit_count: int | None
+    timeout: int | None
+
+    @staticmethod
+    def from_dict_row(data: dict):
+        return DBInstanceConfigMail(
+            uuid=str(data['uuid']),
+            enabled=data['enabled'],
+            provider=data['provider'],
+            sender_name=data['sender_name'],
+            sender_email=data['sender_email'],
+            smtp_host=data['smtp_host'],
+            smtp_port=data['smtp_port'],
+            smtp_security=data['smtp_security'],
+            smtp_username=data['smtp_username'],
+            smtp_password=data['smtp_password'],
+            aws_access_key_id=data['aws_access_key_id'],
+            aws_secret_access_key=data['aws_secret_access_key'],
+            aws_region=data['aws_region'],
+            rate_limit_window=data['rate_limit_window'],
+            rate_limit_count=data['rate_limit_count'],
+            timeout=data['timeout'],
+        )

dsw_database-4.27.0.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.3
+Name: dsw-database
+Version: 4.27.0
+Summary: Library for managing DSW database
+Keywords: dsw,database
+Author: Marek Suchánek
+Author-email: Marek Suchánek <marek.suchanek@ds-wizard.org>
+License: Apache License 2.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Utilities
+Requires-Dist: psycopg[binary]
+Requires-Dist: tenacity
+Requires-Dist: dsw-config==4.27.0
+Requires-Python: >=3.12, <4
+Project-URL: Homepage, https://ds-wizard.org
+Project-URL: Repository, https://github.com/ds-wizard/engine-tools
+Project-URL: Documentation, https://guide.ds-wizard.org
+Project-URL: Issues, https://github.com/ds-wizard/ds-wizard/issues
+Description-Content-Type: text/markdown
+
+# Data Stewardship Wizard: Database
+
+[![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/ds-wizard/engine-tools)](https://github.com/ds-wizard/engine-tools/releases)
+[![PyPI](https://img.shields.io/pypi/v/dsw-database)](https://pypi.org/project/dsw-database/)
+[![LICENSE](https://img.shields.io/github/license/ds-wizard/engine-tools)](LICENSE)
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4975/badge)](https://bestpractices.coreinfrastructure.org/projects/4975)
+[![Python Version](https://img.shields.io/badge/Python-%E2%89%A5%203.7-blue)](https://python.org)
+
+*Library for working with DSW database*
+
+## Usage
+
+Currently, this library is intended for internal use of DSW tooling only. 
+Enhancements for use in custom scripts are planned for future development.
+
+## License
+
+This project is licensed under the Apache License v2.0 - see the
+[LICENSE](LICENSE) file for more details.

dsw_database-4.27.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+dsw/database/__init__.py,sha256=vS926jtn7Xz0jaa83T7llc6f4xpK0wqWYs-CgMO6dVk,56
+dsw/database/build_info.py,sha256=7FfJmNzkLR73Ykl52_X9BmhPIdFBrJmU7vc_pz9IxY8,381
+dsw/database/database.py,sha256=s9E_TTx46GY-rrTs06M-hexegHdKz9s8zsWzptdTbes,27076
+dsw/database/model.py,sha256=BNBK-hAjgUKFAFTIFrO_8fjH0slrGlXJVQlz7SD6EhM,13923
+dsw/database/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsw_database-4.27.0.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+dsw_database-4.27.0.dist-info/METADATA,sha256=zEsK2DVPdfDIBLrB6ubz8OxJ4cnXso8xCuUZcmSb0no,1891
+dsw_database-4.27.0.dist-info/RECORD,,

dsw_database-4.27.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.28
+Root-Is-Purelib: true
+Tag: py3-none-any