mnemosynecore 0.1.7__py3-none-any.whl

mnemosynecore/__init__.py

@@ -0,0 +1,28 @@
+from mnemosynecore.db.vertica import (
+    vertica_conn,
+    vertica_sql,
+    vertica_select,
+    load_sql_tasks_from_dir,
+    read_sql_file,
+    vertica_dedupe,
+    vertica_upsert
+)
+from .mattermost import send_message, send_message_test
+from .superset import superset_request
+from .vault import get_secret, get_secret_test
+
+
+__all__ = [
+    "vertica_conn",
+    "load_sql_tasks_from_dir",
+    "read_sql_file",
+    "vertica_dedupe",
+    "vertica_upsert",
+    "vertica_sql",
+    "vertica_select",
+    "send_message",
+    "send_message_test",
+    "superset_request",
+    "get_secret",
+    "get_secret_test",
+]

mnemosynecore/db/vertica.py

@@ -0,0 +1,316 @@
+import json
+import logging
+from typing import Any, Iterable, Optional
+from typing import List, Optional, Union
+import pandas as pd
+import vertica_python
+from sqlalchemy import create_engine
+from mnemosynecore.vault import get_secret
+
+# Условный импорт Airflow
+HAS_AIRFLOW = False
+try:
+    from airflow.operators.python import get_current_context
+    from airflow import DAG
+    from airflow.utils.task_group import TaskGroup
+    from airflow.operators.dummy import DummyOperator
+    from os import listdir, path
+    HAS_AIRFLOW = True
+except ImportError:
+    pass
+
+
+def load_sql_tasks_from_dir(dir_sql: str, vertica_conn_id: str):
+    """
+    Создаёт словарь VerticaOperator из всех SQL файлов в папке,
+    автоматически используя текущий DAG из контекста.
+    """
+    if not HAS_AIRFLOW:
+        raise ImportError("Для использования load_sql_tasks_from_dir необходимо установить Airflow")
+
+    from airflow.providers.vertica.operators.vertica import VerticaOperator
+
+
+    context = get_current_context()
+    dag = context['dag']  # берём текущий DAG
+
+    tasks = {}
+    files_list = listdir(dir_sql)
+    for filename in files_list:
+        if not filename.endswith(".sql"):
+            continue
+        path_file = path.join(dir_sql, filename)
+        sql = read_sql_file(path_file)
+        if sql:
+            sql_statements = sql.split(';')
+            task_name = 'task_' + filename.replace('.sql', '_vertica')
+            tasks[task_name] = VerticaOperator(
+                sql=sql_statements,
+                task_id=task_name,
+                vertica_conn_id=vertica_conn_id,
+                dag=dag,
+            )
+    return tasks
+
+
+def read_sql_file(file_path: str):
+    if not path.exists(file_path):
+        print('Error: no file ' + file_path)
+        return None
+    with open(file_path, 'r', encoding='utf-8') as f:
+        return f.read()
+
+
+def vertica_dedupe(
+        table_name: str,
+        unique_keys: Union[str, List[str]],
+        conn: Optional[vertica_python.Connection] = None,
+        conn_id: Optional[str] = None,
+        date_col: Optional[str] = None,
+        keep: str = "last",
+        commit: bool = True
+):
+    """
+    Удаляет дубликаты из таблицы Vertica, оставляя только уникальные строки.
+
+    Args:
+        table_name: Полное имя таблицы (schema.table)
+        unique_keys: Столбец или список столбцов для уникальности
+        conn: Готовое соединение с Vertica
+        conn_id: ID подключения/секрета (если conn не передан)
+        date_col: Столбец с датой для определения последней строки при дубликатах
+        keep: 'last' или 'first' — какая запись остаётся среди дубликатов
+        commit: Выполнить commit после удаления
+    """
+
+    if isinstance(unique_keys, str):
+        unique_keys = [unique_keys]
+
+    close_conn = False
+    if conn is None:
+        if not conn_id:
+            raise ValueError("Нужно указать conn или conn_id")
+        conn = vertica_conn(conn_id)
+        close_conn = True
+
+    # Выбираем строки, которые нужно оставить
+    order_clause = f"ORDER BY {date_col} DESC" if date_col and keep == "last" else ""
+    unique_cols = ", ".join(unique_keys)
+
+    dedupe_sql = f"""
+        DELETE FROM {table_name} t
+        USING (
+            SELECT {unique_cols}, ROW_NUMBER() OVER (PARTITION BY {unique_cols} {order_clause}) AS rn
+            FROM {table_name}
+        ) x
+        WHERE t.{unique_keys[0]} = x.{unique_keys[0]}
+          AND x.rn > 1
+    """
+
+    vertica_sql(conn=conn, sql=dedupe_sql, commit=commit)
+
+    if close_conn:
+        conn.close()
+
+    print(f"Удаление дубликатов из {table_name} завершено по ключам: {unique_keys}")
+
+
+def get_connection_as_json(conn_name):
+    import json
+    from airflow.hooks.base import BaseHook
+
+    conn = BaseHook.get_connection(conn_name)
+    ci = {'host': conn.host, 'password': conn.password, 'login': conn.login, 'port': conn.port, 'schema': conn.schema,
+          'extra': conn.extra}
+    return json.dumps(ci)
+
+
+def vertica_upsert(
+        df: pd.DataFrame,
+        table_name: str,
+        unique_keys: Union[str, List[str]],
+        conn=None,
+        date_col: Optional[str] = None,
+        days_back: Optional[int] = None,
+        commit: bool = True
+):
+    """
+    Эффективно обновляет данные в Vertica:
+    - вставляет новые строки,
+    - обновляет существующие,
+    - удаляет дубликаты.
+
+    Args:
+        df: DataFrame с новыми данными
+        table_name: имя таблицы с полным путем (schema.table)
+        unique_keys: столбец или список столбцов для уникальности
+        conn: подключение к Vertica (если None, создается новое)
+        date_col: если указано, фильтруем по последним `days_back` дням
+        days_back: число дней для подгрузки (используется с date_col)
+        commit: выполнять commit после вставки/мержа
+    """
+    if df.empty:
+        print("Нет данных для обновления.")
+        return
+
+    if isinstance(unique_keys, str):
+        unique_keys = [unique_keys]
+
+    # Создаем соединение, если не передано
+    close_conn = False
+    if conn is None:
+        conn = vertica_conn()
+        close_conn = True
+
+    # Создаем временную таблицу
+    temp_table = f"{table_name}_tmp"
+    create_temp_sql = f"""
+        DROP TABLE IF EXISTS {temp_table};
+        CREATE LOCAL TEMP TABLE {temp_table} AS
+        SELECT * FROM {table_name} WHERE 1=0;
+    """
+    vertica_sql(conn, create_temp_sql, commit=False)
+
+    # Вставляем данные во временную таблицу
+    rows = [tuple(x) for x in df.to_numpy()]
+    cols = ", ".join(df.columns)
+    placeholders = ", ".join(["%s"] * len(df.columns))
+
+    insert_sql = f"INSERT INTO {temp_table} ({cols}) VALUES ({placeholders})"
+    vertica_sql(conn, insert_sql, params=rows, many=True, commit=False)
+
+    # Удаляем старые данные по date_col, если указано
+    if date_col and days_back:
+        delete_sql = f"""
+            DELETE FROM {table_name}
+            WHERE {date_col} >= CURRENT_DATE - INTERVAL '{days_back} day';
+        """
+        vertica_sql(conn, delete_sql, commit=False)
+
+    # MERGE с основной таблицей по уникальным ключам
+    merge_conditions = " AND ".join([f"t.{k} = s.{k}" for k in unique_keys])
+    update_assignments = ", ".join([f"{c} = s.{c}" for c in df.columns if c not in unique_keys])
+
+    merge_sql = f"""
+        MERGE INTO {table_name} t
+        USING {temp_table} s
+        ON {merge_conditions}
+        WHEN MATCHED THEN UPDATE SET {update_assignments}
+        WHEN NOT MATCHED THEN INSERT ({cols}) VALUES ({cols});
+    """
+    vertica_sql(conn, merge_sql, commit=False)
+
+    # Финальный commit
+    if commit:
+        conn.commit()
+
+    if close_conn:
+        conn.close()
+
+    print(f"Обновление таблицы {table_name} завершено. {len(df)} строк обработано.")
+
+
+def vertica_conn(conn_id: str) -> vertica_python.Connection:
+    """
+    Создаёт подключение к Vertica через Vault / Airflow Connection.
+
+    :param conn_id: ID секрета (Vault / Airflow)
+    """
+    cfg = get_secret(conn_id)
+
+    return vertica_python.connect(
+        host=cfg["host"],
+        port=int(cfg["port"]),
+        user=cfg["login"],
+        password=cfg["password"],
+        database=cfg.get("schema") or cfg.get("database"),
+        autocommit=False,
+    )
+
+def get_vertica_engine(conn_id: str):
+    """
+    Создаёт SQLAlchemy engine для Vertica через Vault
+    """
+    cfg = json.loads(get_connection_as_json(conn_id))
+
+    vertica_url = (
+        f"vertica+vertica_python://{cfg['login']}:{cfg['password']}@"
+        f"{cfg['host']}:{cfg['port']}/{cfg['schema']}"
+    )
+
+    return create_engine(vertica_url, pool_pre_ping=True)
+
+
+def vertica_sql(
+        *,
+        conn_id: Optional[str] = None,
+        conn: Optional[vertica_python.Connection] = None,
+        sql: str,
+        params: Optional[Iterable[Any]] = None,
+        many: bool = False,
+        commit: bool = True,
+) -> None:
+    """
+    Выполняет SQL-запрос в Vertica.
+
+    Можно передать либо conn_id, либо готовое соединение.
+    """
+
+    if not conn and not conn_id:
+        raise ValueError("Нужно указать conn или conn_id")
+
+    close_conn = False
+    if not conn:
+        conn = vertica_conn(conn_id)
+        close_conn = True
+
+    try:
+        with conn.cursor() as cur:
+            if many:
+                cur.executemany(sql, params)
+            else:
+                cur.execute(sql, params)
+
+        if commit:
+            conn.commit()
+
+    except Exception:
+        conn.rollback()
+        logging.exception("Ошибка выполнения SQL в Vertica")
+        raise
+
+    finally:
+        if close_conn:
+            conn.close()
+
+
+def vertica_select(
+        *,
+        conn_id: Optional[str] = None,
+        conn: Optional[vertica_python.Connection] = None,
+        sql: str,
+        params: Optional[Iterable[Any]] = None,
+) -> pd.DataFrame:
+    """
+    Выполняет SELECT-запрос и возвращает pandas DataFrame.
+    """
+
+    if not conn and not conn_id:
+        raise ValueError("Нужно указать conn или conn_id")
+
+    close_conn = False
+    if not conn:
+        conn = vertica_conn(conn_id)
+        close_conn = True
+
+    try:
+        with conn.cursor() as cur:
+            cur.execute(sql, params)
+            columns = [desc[0] for desc in cur.description]
+            rows = cur.fetchall()
+
+        return pd.DataFrame(rows, columns=columns)
+
+    finally:
+        if close_conn:
+            conn.close()

mnemosynecore/mattermost.py

@@ -0,0 +1,141 @@
+import logging
+import json
+from typing import Optional, Union
+from mattermostdriver import Driver
+from mnemosynecore.vault import get_secret
+from sqlalchemy import create_engine
+from .vault import get_secret_test
+
+
+def get_mattermost_driver_test(bot_id: str, dir_path: str = "./secrets") -> Driver:
+    """
+    Возвращает Mattermost Driver для тестов.
+    Использует JSON-файл вместо Vault.
+    """
+    cfg = get_secret_test(bot_id, dir_path)
+
+    driver = Driver({
+        "url": cfg["host"],
+        "token": cfg["password"],
+        "schema": cfg.get("schema", "https"),
+        "port": int(cfg.get("port", 443)),
+        "basepath": cfg.get("basepath", "/api/v4"),
+    })
+
+    driver.login()
+    return driver
+
+
+def send_message_test(
+    *,
+    channel_id: str,
+    bot_id: str,
+    text: str,
+    dir_path: str = "./secrets",
+    silent: bool = False,
+) -> None:
+    """
+    Отправляет сообщение в Mattermost от имени бота для тестов.
+    Использует локальный JSON вместо Vault.
+    """
+    driver = get_mattermost_driver_test(bot_id, dir_path)
+
+    try:
+        driver.posts.create_post(
+            options={
+                "channel_id": channel_id,
+                "message": text.strip(),
+            }
+        )
+        if not silent:
+            print(f"[TEST] Сообщение отправлено в Mattermost: {channel_id}")
+    except Exception as exc:
+        print(f"[TEST] Ошибка отправки сообщения: {exc}")
+        raise
+
+
+def get_mattermost_driver(bot_id: str) -> Driver:
+    """
+    Создаёт и логинит Mattermost Driver через Vault.
+    """
+    # Проверяем, является ли bot_id строкой JSON
+    if bot_id.startswith('{'):
+        try:
+            cfg = json.loads(bot_id)
+        except json.JSONDecodeError:
+            raise ValueError("Неверный формат JSON для конфигурации Mattermost")
+    else:
+        # Используем старый способ - получаем из Vault
+        cfg = get_secret(bot_id)
+
+    driver = Driver({
+        "url": cfg["host"],
+        "token": cfg["password"],
+        "schema": cfg.get("schema", "https"),
+        "port": int(cfg.get("port", 443)),
+        "basepath": cfg.get("basepath", "/api/v4"),
+    })
+
+    driver.login()
+    return driver
+
+def get_mattermost_conn(conn_id: str) -> dict:
+    """
+    Получает параметры подключения к Mattermost из Vault
+    """
+    cfg_json = json.loads(get_connection_as_json(conn_id))
+
+    return {
+        "host": cfg_json.get("host"),
+        "password": cfg_json.get("password"),
+        "schema": cfg_json.get("schema", "https"),
+        "port": int(cfg_json.get("port", 443)),
+        "basepath": json.loads(cfg_json.get("extra", "{}")).get(
+            "basepath", "/api/v4"
+        ),
+    }
+
+
+def get_connection_as_json(conn_name):
+    import json
+    from airflow.hooks.base import BaseHook
+
+    conn = BaseHook.get_connection(conn_name)
+    ci = {'host': conn.host, 'password': conn.password, 'login': conn.login, 'port': conn.port, 'schema': conn.schema,
+          'extra': conn.extra}
+    return json.dumps(ci)
+
+
+def send_message(
+    *,
+    channel_id: str,
+    bot_id: str,
+    text: str,
+    silent: bool = False,
+) -> None:
+    """
+    Отправляет сообщение в Mattermost от имени бота.
+
+    :param channel_id: ID канала
+    :param bot_id: ID секрета в Vault или JSON-строка конфигурации
+    :param text: Markdown-текст сообщения
+    :param silent: не логировать успешную отправку
+    """
+    driver = get_mattermost_driver(bot_id)
+
+    try:
+        driver.posts.create_post(
+            options={
+                "channel_id": channel_id,
+                "message": text.strip(),
+            }
+        )
+        if not silent:
+            logging.info("Сообщение отправлено в Mattermost: %s", channel_id)
+
+    except Exception as exc:
+        logging.exception(
+            "Ошибка отправки сообщения в Mattermost (channel_id=%s)",
+            channel_id
+        )
+        raise

mnemosynecore/superset.py

@@ -0,0 +1,25 @@
+import requests
+from .vault import get_secret
+
+
+def superset_request(
+    *,
+    endpoint: str,
+    method: str = "GET",
+    payload: dict | None = None,
+    vault_conn_id: str
+):
+
+    cfg = get_secret(vault_conn_id)
+    base_url = cfg["host"]
+
+    headers = {
+        "Authorization": f"Bearer {cfg['password']}",
+        "Content-Type": "application/json",
+    }
+
+    url = f"{base_url.rstrip('/')}/{endpoint.lstrip('/')}"
+
+    resp = requests.request(method, url, json=payload, headers=headers)
+    resp.raise_for_status()
+    return resp.json()

mnemosynecore/vault.py

@@ -0,0 +1,62 @@
+import json
+import os
+from typing import Dict, Optional
+
+
+def get_connection_as_json(conn_id: str) -> str:
+    # Сначала пытаемся получить секрет из переменных окружения
+    secret = os.environ.get(conn_id)
+
+    if not secret:
+        # Если нет в переменных окружения, пробуем получить из Vault
+        try:
+            # Попытка импорта vault_client (если доступен)
+            from mnemosyne.vault.client import VaultClient
+
+            # Создаем клиент Vault
+            vault_client = VaultClient()
+
+            # Получаем секрет из Vault
+            secret = vault_client.get_secret(conn_id)
+
+            if not secret:
+                raise ValueError(f"Секрет {conn_id} не найден ни в переменных окружения, ни в Vault")
+
+        except ImportError:
+            # Если Vault клиент недоступен, бросаем исключение
+            raise ValueError(f"Секрет {conn_id} не найден в переменных окружения и не удалось подключиться к Vault")
+        except Exception as e:
+            raise ValueError(f"Ошибка при получении секрета {conn_id} из Vault: {str(e)}")
+
+    return secret
+
+
+def get_secret(conn_id: str) -> Dict:
+    raw = get_connection_as_json(conn_id)
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Секрет {conn_id} не является корректным JSON: {e}")
+
+def get_connection_as_json_test(conn_id: str, dir_path: str = "./secrets") -> str:
+    """
+    Возвращает JSON-конфиг подключения для тестов.
+    Вместо Vault берёт локальный JSON-файл из dir_path.
+    Файл должен называться <conn_id>.json
+    """
+    file_path = os.path.join(dir_path, f"{conn_id}.json")
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Тестовый секрет {file_path} не найден")
+    with open(file_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+def get_secret_test(conn_id: str, dir_path: str = "./secrets") -> Dict:
+    """
+    Возвращает словарь конфигурации для тестов.
+    Читает локальный JSON вместо Vault.
+    """
+    raw = get_connection_as_json_test(conn_id, dir_path)
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Тестовый секрет {conn_id} не является корректным JSON: {e}")

mnemosynecore/warnings.py

@@ -0,0 +1,8 @@
+import warnings
+
+def old_function():
+    warnings.warn(
+        "old_function устарела, используй new_function",
+        DeprecationWarning,
+        stacklevel=2
+    )

mnemosynecore-0.1.7.dist-info/METADATA

@@ -0,0 +1,278 @@
+Metadata-Version: 2.4
+Name: mnemosynecore
+Version: 0.1.7
+Summary: Internal analytics toolkit for data pipelines
+Author-email: rostilin <rostilin@ozon.ru>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: vertica-python>=1.3
+Requires-Dist: pandas>=2.0
+Requires-Dist: mattermostdriver>=2.0
+Requires-Dist: requests>=2.30
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: airflow
+Requires-Dist: apache-airflow<3.1,>=3.0; extra == "airflow"
+Requires-Dist: apache-airflow-providers-postgres>=5.0; extra == "airflow"
+Requires-Dist: apache-airflow-providers-vertica>=2.0; extra == "airflow"
+Requires-Dist: sqlalchemy<2.0; extra == "airflow"
+
+# mnemosynecore Documentation
+
+## Общее описание
+Библиотека mnemosynecore предоставляет набор инструментов для работы с Vertica БД, 
+Airflow, Mattermost и другими системами аналитики. Она предназначена для автоматизации 
+работы с данными и интеграции различных сервисов.
+
+## Установка
+```bash
+pip install mnemosynecore
+
+Для Airflow:
+pip install mnemosynecore[airflow]
+
+Основные модули
+1. Работа с Vertica (mnemosynecore.db.vertica)
+Функции для работы с БД
+vertica_conn(conn_id) - Создание подключения к Vertica
+from mnemosynecore.db.vertica import vertica_conn
+
+# Подключение к Vertica
+conn = vertica_conn("VERTICA_CONN_ID")
+# Использование соединения
+result = vertica_sql(conn=conn, sql="SELECT * FROM table")
+conn.close()
+
+**vertica_sql(kwargs) - Выполнение SQL запросов
+
+from mnemosynecore.db.vertica import vertica_sql
+
+# Выполнение запроса с ID подключения
+vertica_sql(
+    conn_id="VERTICA_CONN_ID",
+    sql="INSERT INTO table VALUES (%s, %s)",
+    params=[1, "test"]
+)
+
+# Выполнение запроса с готовым соединением
+vertica_sql(conn=conn, sql="UPDATE table SET col = %s WHERE id = %s", params=[100, 1])
+
+**vertica_select(kwargs) - Выполнение SELECT запросов
+
+from mnemosynecore.db.vertica import vertica_select
+
+# Получение данных в DataFrame
+df = vertica_select(
+    conn_id="VERTICA_CONN_ID",
+    sql="SELECT * FROM table WHERE id = %s",
+    params=[123]
+)
+print(df.head())
+
+**vertica_dedupe(table_name, unique_keys, kwargs) - Удаление дубликатов
+
+from mnemosynecore.db.vertica import vertica_dedupe
+
+# Удаление дубликатов по одному ключу
+vertica_dedupe(
+    table_name="schema.table",
+    unique_keys="id",
+    conn_id="VERTICA_CONN_ID"
+)
+
+# Удаление дубликатов по нескольким ключам с учетом даты
+vertica_dedupe(
+    table_name="schema.table",
+    unique_keys=["id", "date"],
+    conn_id="VERTICA_CONN_ID",
+    date_col="created_at",
+    keep="last"
+)
+
+**vertica_upsert(df, table_name, unique_keys, kwargs) - Upsert операции
+
+from mnemosynecore.db.vertica import vertica_upsert
+import pandas as pd
+
+# Подготовка данных
+df = pd.DataFrame({
+    'id': [1, 2, 3],
+    'name': ['Alice', 'Bob', 'Charlie'],
+    'value': [100, 200, 300]
+})
+
+# Upsert данных
+vertica_upsert(
+    df=df,
+    table_name="schema.table",
+    unique_keys=["id"],
+    conn_id="VERTICA_CONN_ID"
+)
+
+load_sql_tasks_from_dir(dir_sql, vertica_conn_id) - Создание задач из SQL файлов
+
+from mnemosynecore.db.vertica import load_sql_tasks_from_dir
+
+# Создание задач из директории SQL файлов
+tasks = load_sql_tasks_from_dir("/path/to/sql/files", "VERTICA_CONN_ID")
+
+# Использование в Airflow DAG
+from airflow import DAG
+from airflow.utils.task_group import TaskGroup
+
+with DAG("my_dag") as dag:
+    with TaskGroup("vertica_tasks") as vertica_group:
+        for task in tasks.values():
+            task
+
+read_sql_file(file_path) - Чтение SQL файлов
+from mnemosynecore.db.vertica import read_sql_file
+
+# Чтение SQL файла
+sql_content = read_sql_file("/path/to/query.sql")
+if sql_content:
+    print("SQL загружен успешно")
+
+2. Работа с секретами (mnemosynecore.vault)
+get_secret(conn_id) - Получение секретов
+from mnemosynecore.vault import get_secret
+
+# Получение секрета из Vault
+secret = get_secret("SECRET_ID")
+print(secret["host"])  # Хост базы данных
+print(secret["password"])  # Пароль
+
+3. Интеграция с Mattermost (mnemosynecore.mattermost)
+send_message(channel_id, bot_id, text, silent=False) - Отправка сообщений
+
+from mnemosynecore.mattermost import send_message
+
+# Отправка сообщения в канал
+send_message(
+    channel_id="s5c11srqkf8j3pbdwfbn9imrde",
+    bot_id="MATTERMOST_BOT_ID",
+    text="Привет! Это тестовое сообщение"
+)
+
+# Отправка Markdown сообщения
+send_message(
+    channel_id="s5c11srqkf8j3pbdwfbn9imrde",
+    bot_id="MATTERMOST_BOT_ID",
+    text="""
+    📊 **Отчет по данным** 📊
+    
+    - Данные успешно загружены
+    - Обработано записей: 1000
+    - Время выполнения: 2 минуты
+    
+    [Подробнее](https://your-dashboard.com)
+    """
+)
+
+4. Интеграция с Superset (mnemosynecore.superset)
+superset_request(endpoint, method="GET", payload=None, vault_conn_id) - Запросы к Superset
+from mnemosynecore.superset import superset_request
+
+# Получение информации о дашборде
+response = superset_request(
+    endpoint="/api/v1/dashboard/123",
+    method="GET",
+    vault_conn_id="SUPERSET_CONN_ID"
+)
+
+# Создание нового дашборда
+new_dashboard = superset_request(
+    endpoint="/api/v1/dashboard/",
+    method="POST",
+    payload={"name": "New Dashboard"},
+    vault_conn_id="SUPERSET_CONN_ID"
+)
+
+Конфигурация секретов
+Формат секретов для Vault
+Для Vertica:
+{
+    "host": "vertica-host.com",
+    "port": "5433",
+    "login": "username",
+    "password": "password",
+    "schema": "database_schema"
+}
+
+Для Mattermost:
+{
+    "host": "https://mattermost.company.com",
+    "password": "bot_token_here",
+    "scheme": "https",
+    "port": 443,
+    "basepath": "/api/v4"
+}
+
+Для Superset:
+{
+    "host": "https://superset.company.com",
+    "password": "access_token_here",
+    "scheme": "https",
+    "port": 443,
+    "basepath": "/api/v1"
+}
+
+Примеры использования
+Пример 1: Полный пайплайн работы с Vertica
+from mnemosynecore.db.vertica import vertica_conn, vertica_sql, vertica_select, vertica_upsert
+from mnemosynecore.mattermost import send_message
+import pandas as pd
+
+def process_data_pipeline():
+    # Подключение к Vertica
+    conn = vertica_conn("VERTICA_CONN_ID")
+    
+    try:
+        # Выполнение запроса
+        df = vertica_select(
+            conn=conn,
+            sql="SELECT * FROM source_table WHERE date > %s",
+            params=['2023-01-01']
+        )
+        
+        # Обработка данных
+        processed_df = df.groupby('category').sum()
+        
+        # Upsert в целевую таблицу
+        vertica_upsert(
+            df=processed_df,
+            table_name="analytics.summary",
+            unique_keys=["category"],
+            conn=conn
+        )
+        
+        # Отправка уведомления
+        send_message(
+            channel_id="s5c11srqkf8j3pbdwfbn9imrde",
+            bot_id="MATTERMOST_BOT_ID",
+            text="✅ Пайплайн выполнен успешно"
+        )
+        
+    except Exception as e:
+        send_message(
+            channel_id="s5c11srqkf8j3pbdwfbn9imrde",
+            bot_id="MATTERMOST_BOT_ID",
+            text=f"❌ Ошибка в пайплайне: {str(e)}"
+        )
+        raise
+    finally:
+        conn.close()
+
+Пример 2: Автоматическая очистка дубликатов
+
+from mnemosynecore.db.vertica import vertica_dedupe
+
+def remove_duplicates():
+    vertica_dedupe(
+        table_name="analytics.user_events",
+        unique_keys=["user_id", "event_time"],
+        conn_id="VERTICA_CONN_ID",
+        date_col="event_time",
+        keep="last"
+    )
+

mnemosynecore-0.1.7.dist-info/RECORD

@@ -0,0 +1,11 @@
+mnemosynecore/__init__.py,sha256=ZekrYOivI7PuaUaTVXkaCn5xo09mjRAFBuf8v3mboJA,607
+mnemosynecore/config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mnemosynecore/mattermost.py,sha256=Kx24iU7Ncltre2HgBA2GjX5JD78JJ3kj8NOKiWQanf4,4287
+mnemosynecore/superset.py,sha256=QtQ7ZXYD0evCQB_NQJiFWtvmCT1Sx3su1Msg2G1Uhxs,548
+mnemosynecore/vault.py,sha256=CuJCMIqtTxi_Wcl1FuZaILPf-YZaBU4p8BM07d4xqy4,2746
+mnemosynecore/warnings.py,sha256=CWKRY2VZrf-MijWjUTZbhA48wC0jIjSULpV31rRpKyc,184
+mnemosynecore/db/vertica.py,sha256=w_0nZ2uRuL27TxpmD_60frriCkG05uyaDzNEOqfCN1w,10442
+mnemosynecore-0.1.7.dist-info/METADATA,sha256=4Y3f31A35zgsKy7mz3QRPknOoVikxCt7XPRt4s4grPU,8534
+mnemosynecore-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mnemosynecore-0.1.7.dist-info/top_level.txt,sha256=v87precv4itopYOciTHITY3GSFqZsGkgenQmDFKWpFU,14
+mnemosynecore-0.1.7.dist-info/RECORD,,

mnemosynecore-0.1.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mnemosynecore-0.1.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+mnemosynecore