dmart 1.4.40.post8__py3-none-any.whl

dmart/__init__.py

@@ -0,0 +1,7 @@
+import os
+import sys
+
+
+_pkg_dir = os.path.dirname(__file__)
+if _pkg_dir not in sys.path:
+    sys.path.insert(0, _pkg_dir)

dmart/alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

dmart/alembic/env.py

@@ -0,0 +1,91 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+from data_adapters.sql.create_tables import \
+    metadata
+
+from utils.settings import settings
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+driver = settings.database_driver.replace('+asyncpg', '+psycopg')
+database_connection_string = f"{driver}://{settings.database_username}:{settings.database_password}@{settings.database_host}:{settings.database_port}"
+connection_string = f"{database_connection_string}/{settings.database_name}"
+config.set_main_option('sqlalchemy.url', connection_string)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = metadata #SQLModel.metadata
+print(metadata.tables.keys())
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata,
+            render_as_batch=True,
+            user_module_prefix="sqlmodel.sql.sqltypes.",
+
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

dmart/alembic/notes.txt

@@ -0,0 +1,11 @@
+# 1st : Make sure in alembic.ini to have proper db config for sqlalchemy.url
+
+
+# To establish the base for a previously created database run the following
+
+CREATE TABLE alembic_version (
+    version_num VARCHAR(32) NOT NULL,
+    CONSTRAINT alembic_version_pkc PRIMARY KEY (version_num)
+);
+
+INSERT INTO alembic_version (version_num) VALUES ('74288ccbd3b5') RETURNING alembic_version.version_num;

dmart/alembic/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+import sqlmodel.sql.sqltypes
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

dmart/alembic/scripts/calculate_checksums.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env -S BACKEND_ENV=config.env python3
+import asyncio
+import hashlib
+import json
+from datetime import datetime
+from sqlalchemy import select, update, func
+from data_adapters.sql.adapter import SQLAdapter
+from data_adapters.sql.create_tables import Histories, Users, Entries, Spaces, Roles, Permissions
+
+def flatten_dict(d, parent_key='', sep='.'):
+    items = []
+    for k, v in d.items():
+        new_key = parent_key + sep + k if parent_key else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+async def migrate_checksums():
+    db = SQLAdapter()
+    
+    async with db.get_session() as session:
+        resource_tables = [Users, Permissions, Roles, Entries, Spaces]
+        
+        for resource_table in resource_tables:
+            print(f"Processing table: {resource_table.__tablename__}")
+            
+            # Fetch all records from the current table
+            stmt = select(resource_table)
+            result = await session.execute(stmt)
+            records = result.scalars().all()
+            
+            print(f"Found {len(records)} records in {resource_table.__tablename__}")
+
+            batch_size = 1000
+            for i in range(0, len(records), batch_size):
+                batch = records[i:i + batch_size]
+                print(f"Processing batch {i // batch_size + 1} ({len(batch)} records) for {resource_table.__tablename__}...")
+                
+                for record in batch:
+                    try:
+                        async with session.begin_nested():
+                            record_dict = record.model_dump()
+                            flat_record = flatten_dict(record_dict)
+
+                            new_version_json = json.dumps(flat_record, sort_keys=True, default=str)
+                            new_checksum = hashlib.sha1(new_version_json.encode()).hexdigest()
+
+                            record.last_checksum_history = new_checksum
+                            session.add(record)
+
+                            history_stmt = select(Histories).where(
+                                Histories.space_name == record.space_name,
+                                Histories.subpath == record.subpath,
+                                Histories.shortname == record.shortname
+                            ).order_by(Histories.timestamp.desc()).limit(1)
+                            
+                            history_result = await session.execute(history_stmt)
+                            latest_history = history_result.scalars().first()
+
+                            if latest_history:
+                                latest_history.last_checksum_history = new_checksum
+                                session.add(latest_history)
+                            else:
+                                print(f"No history found for {record.space_name}/{record.subpath}/{record.shortname}")
+                    
+                    except Exception as e:
+                        print(f"Error processing {record.space_name}/{record.shortname} in {resource_table.__tablename__}: {e}")
+                
+                await session.commit()
+                print(f"Batch {i // batch_size + 1} committed for {resource_table.__tablename__}.")
+        
+        print("Migration completed.")
+
+if __name__ == "__main__":
+    asyncio.run(migrate_checksums())

dmart/alembic/scripts/migration_f7a4949eed19.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env -S BACKEND_ENV=config.env python3
+from sqlmodel import select
+
+from data_adapters.sql.adapter import SQLAdapter
+from data_adapters.sql.create_tables import Entries, Permissions, Roles, Spaces, Users
+from utils.query_policies_helper import generate_query_policies
+
+
+print("[INFO]  [dmart.script] Performing post-upgrade data migration (calc-query-policies)")
+with SQLAdapter().get_session() as session:
+    for table in [Entries, Permissions, Roles, Spaces, Users]:
+        print(f"[INFO]  [dmart.script] Processing table: {table}")
+        records = session.exec(select(table)).all()
+        print(f"[INFO]  [dmart.script] Processing {len(records)} records")
+        for record in records:
+            if not record.query_policies:
+                record.query_policies = generate_query_policies(
+                    space_name=record.space_name,
+                    subpath=f"{record.subpath}/{record.shortname}" if record.resource_type == 'folder' else record.subpath,
+                    resource_type=record.resource_type,
+                    is_active=record.is_active,
+                    owner_shortname=record.owner_shortname,
+                    owner_group_shortname= record.owner_group_shortname if  hasattr(record, 'owner_group_shortname') else "",
+                )
+                session.add(record)
+                print(".", end="\r")
+        session.commit()
+print("[INFO]  [dmart.script] Post-upgrade data migration completed")

dmart/alembic/versions/0f3d2b1a7c21_add_authz_materialized_views.py

@@ -0,0 +1,87 @@
+"""add authz materialized views and meta table
+
+Revision ID: 0f3d2b1a7c21
+Revises: 98ecd6f56f9a
+Create Date: 2025-09-25 07:40:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = '0f3d2b1a7c21'
+down_revision: Union[str, None] = '98ecd6f56f9a'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Create meta table to track MV refresh times
+    op.execute(
+        """
+        CREATE TABLE IF NOT EXISTS authz_mv_meta (
+            id INT PRIMARY KEY,
+            last_source_ts TIMESTAMPTZ,
+            refreshed_at TIMESTAMPTZ
+        )
+        """
+    )
+    # Seed a single row with id=1 if not exists
+    op.execute(
+        """
+        INSERT INTO authz_mv_meta(id, last_source_ts, refreshed_at)
+        VALUES (1, to_timestamp(0), now())
+        ON CONFLICT (id) DO NOTHING
+        """
+    )
+
+    # Create materialized view for user->roles
+    op.execute(
+        """
+        CREATE MATERIALIZED VIEW IF NOT EXISTS mv_user_roles AS
+        SELECT u.shortname AS user_shortname,
+               r.shortname AS role_shortname
+        FROM users u
+        JOIN LATERAL jsonb_array_elements_text(u.roles) AS role_name ON TRUE
+        JOIN roles r ON r.shortname = role_name
+        """
+    )
+    op.execute(
+        """
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_mv_user_roles_unique
+        ON mv_user_roles (user_shortname, role_shortname)
+        """
+    )
+
+    # Create materialized view for role->permissions
+    op.execute(
+        """
+        CREATE MATERIALIZED VIEW IF NOT EXISTS mv_role_permissions AS
+        SELECT r.shortname AS role_shortname,
+               p.shortname AS permission_shortname
+        FROM roles r
+        JOIN LATERAL jsonb_array_elements_text(r.permissions) AS perm_name ON TRUE
+        JOIN permissions p ON p.shortname = perm_name
+        """
+    )
+    op.execute(
+        """
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_mv_role_permissions_unique
+        ON mv_role_permissions (role_shortname, permission_shortname)
+        """
+    )
+
+
+def downgrade() -> None:
+    # Drop unique indexes first
+    op.execute("DROP INDEX IF EXISTS idx_mv_role_permissions_unique")
+    op.execute("DROP INDEX IF EXISTS idx_mv_user_roles_unique")
+
+    # Drop materialized views
+    op.execute("DROP MATERIALIZED VIEW IF EXISTS mv_role_permissions")
+    op.execute("DROP MATERIALIZED VIEW IF EXISTS mv_user_roles")
+
+    # Drop meta table
+    op.execute("DROP TABLE IF EXISTS authz_mv_meta")

dmart/alembic/versions/10d2041b94d4_last_checksum_history.py

@@ -0,0 +1,62 @@
+"""last_checksum_history
+
+Revision ID: 10d2041b94d4
+Revises: eb5f1ec65156
+Create Date: 2026-01-11 16:56:50.108607
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = '10d2041b94d4'
+down_revision: Union[str, None] = 'eb5f1ec65156'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('users', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('last_checksum_history', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+    with op.batch_alter_table('permissions', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('last_checksum_history', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+    with op.batch_alter_table('roles', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('last_checksum_history', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+    with op.batch_alter_table('entries', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('last_checksum_history', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+    with op.batch_alter_table('spaces', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('last_checksum_history', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+    with op.batch_alter_table('histories', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('last_checksum_history', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+    with op.batch_alter_table('attachments', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('last_checksum_history', sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+
+
+# ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('users', schema=None) as batch_op:
+        batch_op.drop_column('last_checksum_history')
+    with op.batch_alter_table('permissions', schema=None) as batch_op:
+        batch_op.drop_column('last_checksum_history')
+    with op.batch_alter_table('roles', schema=None) as batch_op:
+        batch_op.drop_column('last_checksum_history')
+    with op.batch_alter_table('entries', schema=None) as batch_op:
+        batch_op.drop_column('last_checksum_history')
+    with op.batch_alter_table('spaces', schema=None) as batch_op:
+        batch_op.drop_column('last_checksum_history')
+    with op.batch_alter_table('histories', schema=None) as batch_op:
+        batch_op.drop_column('last_checksum_history')
+    with op.batch_alter_table('attachments', schema=None) as batch_op:
+        batch_op.drop_column('last_checksum_history')
+
+
+    # ### end Alembic commands ###

dmart/alembic/versions/1cf4e1ee3cb8_ext_permission_with_filter_fields_values.py

@@ -0,0 +1,33 @@
+"""ext permission with filter_fields_values
+
+Revision ID: 1cf4e1ee3cb8
+Revises: 3c8bca2219cc
+Create Date: 2025-09-18 10:37:55.573932
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision: str = '1cf4e1ee3cb8'
+down_revision: Union[str, None] = '3c8bca2219cc'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table('permissions', schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column('filter_fields_values', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        )
+
+
+def downgrade() -> None:
+    with op.batch_alter_table('permissions', schema=None) as batch_op:
+        batch_op.drop_column('filter_fields_values')

dmart/alembic/versions/26bfe19b49d4_rm_failedloginattempts.py

@@ -0,0 +1,42 @@
+"""rm FailedLoginAttempts
+
+Revision ID: 26bfe19b49d4
+Revises: 74288ccbd3b5
+Create Date: 2024-11-25 15:40:46.757073
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '26bfe19b49d4'
+down_revision: Union[str, None] = '74288ccbd3b5'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('failedloginattempts')
+    with op.batch_alter_table('users', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('attempt_count', sa.Integer(), nullable=True))
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('users', schema=None) as batch_op:
+        batch_op.drop_column('attempt_count')
+
+    op.create_table('failedloginattempts',
+    sa.Column('uuid', sa.UUID(), autoincrement=False, nullable=False),
+    sa.Column('shortname', sa.VARCHAR(), autoincrement=False, nullable=False),
+    sa.Column('attempt_count', sa.INTEGER(), autoincrement=False, nullable=False),
+    sa.Column('timestamp', postgresql.TIMESTAMP(), autoincrement=False, nullable=False),
+    sa.PrimaryKeyConstraint('uuid', name='failedloginattempts_pkey')
+    )
+    # ### end Alembic commands ###

dmart/alembic/versions/3c8bca2219cc_add_otp_table.py

@@ -0,0 +1,38 @@
+"""add otp table
+
+Revision ID: 3c8bca2219cc
+Revises: 9aae9138c4ef
+Create Date: 2025-04-27 15:28:53.704608
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '3c8bca2219cc'
+down_revision: Union[str, None] = '9aae9138c4ef'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.execute("CREATE EXTENSION IF NOT EXISTS hstore")
+    op.create_table('otp',
+    sa.Column('key', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+    sa.Column('value', postgresql.HSTORE(text_type=sa.Text()), nullable=False),
+    sa.Column('timestamp', sa.DateTime(), nullable=False),
+    sa.PrimaryKeyConstraint('key')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('otp')
+    # ### end Alembic commands ###

dmart/alembic/versions/6675fd9dfe42_remove_unique_from_sessions_table.py

@@ -0,0 +1,36 @@
+"""remove unique from Sessions table
+
+Revision ID: 6675fd9dfe42
+Revises: 7520a89a8467
+Create Date: 2024-12-29 16:26:29.871839
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision: str = '6675fd9dfe42'
+down_revision: Union[str, None] = '7520a89a8467'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('sessions', schema=None) as batch_op:
+        batch_op.drop_constraint('sessions_shortname_key', type_='unique')
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('sessions', schema=None) as batch_op:
+        batch_op.create_unique_constraint('sessions_shortname_key', ['shortname'])
+
+    # ### end Alembic commands ###

dmart/alembic/versions/71bc1df82e6a_adding_user_last_login_at.py

@@ -0,0 +1,43 @@
+"""adding user.last_login_at
+
+Revision ID: 71bc1df82e6a
+Revises: 0f3d2b1a7c21
+Create Date: 2025-11-16 19:40:40.794367
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = '71bc1df82e6a'
+down_revision: Union[str, None] = '0f3d2b1a7c21'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('authz_mv_meta')
+    with op.batch_alter_table('users', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('last_login', postgresql.JSONB(astext_type=sa.Text()), nullable=True))
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('users', schema=None) as batch_op:
+        batch_op.drop_column('last_login')
+
+    op.create_table('authz_mv_meta',
+    sa.Column('id', sa.INTEGER(), autoincrement=False, nullable=False),
+    sa.Column('last_source_ts', postgresql.TIMESTAMP(timezone=True), autoincrement=False, nullable=True),
+    sa.Column('refreshed_at', postgresql.TIMESTAMP(timezone=True), autoincrement=False, nullable=True),
+    sa.PrimaryKeyConstraint('id', name=op.f('authz_mv_meta_pkey'))
+    )
+    # ### end Alembic commands ###