al-data-utils 0.3.1__py3-none-any.whl

al_data_utils/git_utils/git_utils.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+import os
+import subprocess
+from pathlib import Path
+from typing import Iterable, Optional
+
+from al_data_utils import logging_utils
+
+
+class GitError(RuntimeError):
+    pass
+
+
+def _run_git(args: Iterable[str], cwd: Optional[os.PathLike[str] | str] = None) -> str:
+    cmd = ['git', *args]
+
+    # nice readable command for logs
+    cmd_str = ' '.join(cmd)
+    cwd_str = str(cwd) if cwd else os.getcwd()
+
+    logging_utils.info(f'[git] run: {cmd_str} (cwd={cwd_str})')
+
+    try:
+        res = subprocess.run(
+            cmd,
+            cwd=cwd,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        out = (res.stdout or '').strip()
+        err = (res.stderr or '').strip()
+
+        # log only if anything interesting
+        if out:
+            logging_utils.info(f'[git] ok: {cmd_str} | stdout: {out}')
+        elif err:
+            # some git commands write non-error info to stderr
+            logging_utils.info(f'[git] ok: {cmd_str} | stderr: {err}')
+        else:
+            logging_utils.info(f'[git] ok: {cmd_str}')
+
+        return out
+
+    except subprocess.CalledProcessError as exc:
+        out = (exc.stdout or '').strip()
+        err = (exc.stderr or '').strip()
+        msg = err or out or 'git command failed'
+        logging_utils.error(f'[git] fail: {cmd_str} | {msg}')
+        raise GitError(msg) from exc
+
+
+def _is_nothing_to_commit(msg: str) -> bool:
+    m = (msg or '').lower()
+    return (
+        'nothing to commit' in m
+        or 'working tree clean' in m
+        or 'no changes added to commit' in m
+    )
+
+
+def commit_all_changes(path: os.PathLike[str] | str, message: str) -> bool:
+    """
+    Stage all changes and commit.
+    Returns True if a commit was created, False if there was nothing to commit.
+    """
+    _run_git(['add', '--all'], cwd=path)
+
+    # Fast check: if clean after add => nothing to commit
+    if is_clean(path):
+        logging_utils.info('[git] nothing to commit (repo is clean)')
+        return False
+
+    try:
+        _run_git(['commit', '-m', message], cwd=path)
+        return True
+    except GitError as e:
+        # Extra safety: treat "nothing to commit" as non-fatal
+        if _is_nothing_to_commit(str(e)):
+            logging_utils.info('[git] nothing to commit (commit skipped)')
+            return False
+        raise
+
+
+def push_changes(
+    path: os.PathLike[str] | str, remote: str = 'origin', branch: Optional[str] = None
+) -> None:
+    args = ['push', remote]
+    if branch:
+        args.append(branch)
+    _run_git(args, cwd=path)
+
+
+def is_git_repo(path: os.PathLike[str] | str) -> bool:
+    try:
+        _run_git(['rev-parse', '--is-inside-work-tree'], cwd=path)
+        return True
+    except GitError:
+        return False
+
+
+def repo_root(path: os.PathLike[str] | str) -> Path:
+    out = _run_git(['rev-parse', '--show-toplevel'], cwd=path)
+    return Path(out)
+
+
+def current_branch(path: os.PathLike[str] | str) -> str:
+    return _run_git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd=path)
+
+
+def current_commit(path: os.PathLike[str] | str, short: bool = True) -> str:
+    args = ['rev-parse']
+    if short:
+        args.append('--short')
+    args.append('HEAD')
+    return _run_git(args, cwd=path)
+
+
+def is_clean(path: os.PathLike[str] | str) -> bool:
+    return _run_git(['status', '--porcelain'], cwd=path) == ''
+
+
+def list_tags(path: os.PathLike[str] | str) -> list[str]:
+    out = _run_git(['tag', '--list'], cwd=path)
+    return [t for t in out.splitlines() if t]
+
+
+def list_branches(path: os.PathLike[str] | str, remote: bool = False) -> list[str]:
+    args = ['branch', '--list']
+    if remote:
+        args = ['branch', '--remote', '--list']
+    out = _run_git(args, cwd=path)
+    return [b.strip().lstrip('* ').strip() for b in out.splitlines() if b.strip()]
+
+
+def file_last_commit(
+    path: os.PathLike[str] | str, file_path: os.PathLike[str] | str
+) -> str:
+    return _run_git(
+        ['log', '-n', '1', '--pretty=format:%H', '--', str(file_path)], cwd=path
+    )

al_data_utils/logging_utils/__init__.py

@@ -0,0 +1,3 @@
+from .logging_utils import configure_logging, error, info, warning
+
+__all__ = ["configure_logging", "info", "warning", "error"]

al_data_utils/logging_utils/logging_utils.py

@@ -0,0 +1,39 @@
+"""
+module encapsulating logging config
+
+stand-alone module makes sure the config is called first
+and shared across modules
+
+expected usage:
+
+    from al_data_utils.logging_utils import info, warning, error
+
+    info("info message")
+    warning("warning message")
+    error("error message")
+"""
+
+import logging
+from logging import error, info, warning  # re-exported
+
+
+def configure_logging(level: int = logging.INFO) -> None:
+    """
+    Configure root logging once.
+    In environments like Airflow, their logging may already be configured.
+    """
+    root = logging.getLogger()
+    if root.handlers:
+        # already configured by something else (or by earlier import)
+        return
+
+    logging.basicConfig(
+        level=level,
+        format="[{asctime}] {{{name}}} {levelname} - {message}",
+        style="{",
+        datefmt="%Y-%m-%d %H:%M:%S %z",
+    )
+
+
+# Configure on import (keeps your "stand-alone module" behavior)
+configure_logging()

al_data_utils/ones_api_utils/__init__.py

@@ -0,0 +1,3 @@
+from .ones_api_utils import OneSAPIClient
+
+__all__ = ['OneSAPIClient']

al_data_utils/ones_api_utils/ones_api_utils.py

@@ -0,0 +1,61 @@
+import requests
+from requests.auth import HTTPBasicAuth
+import traceback
+
+from al_data_utils import logging_utils
+
+
+class OneSAPIClient:
+    def __init__(self, login, password, base_url):
+        self.base_url = base_url
+
+        self._login = login
+        self._password = password
+
+    def get_data_from_1S_api(self, payload, path):
+        """Retrieve all objects from the API."""
+
+        url = f'{self.base_url}{path}'
+        headers = self._browser_headers()
+
+        try:
+            response = requests.post(
+                url,
+                auth=HTTPBasicAuth(self._login, self._password),
+                headers=headers,
+                json=payload,
+            )
+
+            if response.status_code == 200:
+                logging_utils.info(':) Successfully retrieved data.')
+                data = response.json()
+                response = {
+                    'run_result': 200,
+                    'run_response': {'success': True, 'errors': []},
+                    'data': data,
+                }
+
+            else:
+                logging_utils.error(
+                    f'Failed to retrieve data. Status code: {response.status_code}'
+                )
+                content = response.content.decode('utf-8')
+                logging_utils.error(content)
+                response = {
+                    'run_result': 400,
+                    'run_response': {'success': False, 'errors': content},
+                    'rows_loaded': 0,
+                }
+        except Exception as e:
+            response = {
+                'run_result': 400,
+                'run_response': {'success': False, 'errors': str(e)},
+                'rows_loaded': 0,
+            }
+            traceback.print_exc()
+
+        return response
+
+    def _browser_headers(self):
+        """Return headers mimicking a browser request."""
+        return {'Authorization': 'Basic', 'Content-Type': 'application/json'}

al_data_utils/sql_utils/__init__.py

@@ -0,0 +1,3 @@
+from .sql_utils import (SQLDialect, UnifiedSQLClient, tsql_nstr)
+
+__all__ = ['SQLDialect', 'UnifiedSQLClient', 'tsql_nstr']

al_data_utils/sql_utils/sql_utils.py

@@ -0,0 +1,158 @@
+import pandas as pd
+from sqlalchemy import create_engine, event, text
+from urllib.parse import quote_plus
+from enum import Flag, auto
+
+
+class SQLDialect(Flag):
+    POSTGRESQL = auto()
+    MYSQL = auto()
+    MSSQL = auto()
+    SNOWFLAKE = auto()
+
+
+class UnifiedSQLClient:
+    def __init__(self, dialect: SQLDialect | str, params: dict) -> None:
+        """
+        Initialize the Unified SQL client with support for PostgreSQL, MySQL, MSSQL, and Snowflake.
+
+        Args:
+            dialect (SQLDialect): Enum value indicating which SQL dialect to use ('postgresql', 'mysql', 'mssql', 'snowflake').
+
+            params (dict): Dictionary of connection parameters. Required keys vary by dialect:
+
+                Common:
+                    - host (str): Database host (not required for Snowflake).
+                    - port (int or str): Database port.
+                    - database (str): Database name.
+                    - username (str): Database username.
+                    - password (str): Database password or key passphrase (if using Snowflake private key).
+
+                MSSQL-specific:
+                    - driver (str): ODBC driver name (e.g., 'ODBC Driver 17 for SQL Server').
+
+                Snowflake-specific:
+                    - account (str): Snowflake account identifier (e.g., 'abc-xy12345').
+                    - warehouse (str): Snowflake warehouse name.
+                    - private_key (str, optional): PEM-encoded private key string for key-pair authentication.
+                    - passphrase (str, optional): Passphrase to decrypt the private key.
+        """
+
+        self.dialect = self.parse_dialect(dialect)
+
+        host = quote_plus(params.get('host', params.get('server', '')))
+        database = quote_plus(params.get('database', ''))
+        username = quote_plus(params.get('username', params.get('user', '')))
+        password = quote_plus(params.get('password', ''))
+        driver = quote_plus(params.get('driver', ''))
+        if 'driver' not in params:
+            from al_data_utils import airflow_utils
+
+            driver = airflow_utils.get_variable_value('core_mssql_odbc_driver')
+
+        connect_args = {}
+
+        if self.dialect == SQLDialect.POSTGRESQL:
+            port = params.get('port', 5432)
+            self.connection_string = (
+                f'postgresql+psycopg2://{username}:{password}@{host}:{port}/{database}'
+            )
+
+        elif self.dialect == SQLDialect.MYSQL:
+            port = params.get('port', 3306)
+            charset = params.get('charset', 'utf8mb4')
+            self.connection_string = f'mysql+pymysql://{username}:{password}@{host}:{port}/{database}?charset={charset}'
+
+        elif self.dialect == SQLDialect.MSSQL:
+            port = params.get('port', 1433)
+            encrypt = params.get('encrypt', 'yes')
+            self.connection_string = f'mssql+pyodbc://{username}:{password}@{host}:{port}/{database}?driver={driver.replace(" ", "+")}&TrustServerCertificate=yes&Encrypt={encrypt}'
+        elif self.dialect == SQLDialect.SNOWFLAKE:
+            warehouse = params['warehouse']
+            account = params['account']
+            if 'private_key' in params:
+                from modules import key_auth_utils
+
+                private_key_bytes = key_auth_utils.get_private_key(
+                    params['private_key'], params['key_password'], result_format='DER'
+                )
+
+                self.connection_string = (
+                    f'snowflake://{username}@{account}?warehouse={warehouse}/{database}'
+                )
+
+                connect_args = {'private_key': private_key_bytes}
+
+            else:
+                self.connection_string = f'snowflake://{username}:{password}@{account}?warehouse={warehouse}/{database}'
+
+        else:
+            raise ValueError(f'Unsupported dialect: {dialect}')
+
+        self.engine = create_engine(self.connection_string, connect_args=connect_args)
+
+    @staticmethod
+    def parse_dialect(value: str | SQLDialect) -> SQLDialect:
+        if isinstance(value, SQLDialect):
+            return value
+        try:
+            return SQLDialect[value.upper()]
+        except KeyError as e:
+            raise ValueError(f'Unknown dialect: {value}') from e
+
+    def read_sql_to_df(self, query: str, params: dict | None = None) -> pd.DataFrame:
+        """Run a query and return a pandas DataFrame."""
+        with self.engine.connect() as conn:
+            df = pd.read_sql(query, conn, params=params)
+        return df
+
+    def write_df_to_sql(
+        self,
+        df: pd.DataFrame,
+        table_name: str,
+        schema_name: str = 'dbo',
+        if_exists: str = 'append',
+        index: bool = False,
+    ):
+        """Write a pandas DataFrame to a SQL table."""
+        with self.engine.begin() as conn:
+            df.to_sql(
+                table_name,
+                schema=schema_name,
+                con=conn,
+                if_exists=if_exists,
+                index=index,
+            )
+
+    def execute_command(self, command: str, params: dict | None = None) -> None:
+        """Execute a raw SQL command (e.g., INSERT, UPDATE, or stored procedure)."""
+        with self.engine.begin() as conn:
+            conn.execute(text(command), params)
+
+    def execute_command_with_result_to_df(
+        self, query: str, params: dict | None = None
+    ) -> pd.DataFrame:
+        """Run a query and return a pandas DataFrame."""
+        with self.engine.begin() as conn:
+            df = pd.read_sql(query, conn, params=params)
+        return df
+
+    def execute_command_with_result_to_dicts(
+        self, query: str, params: dict[str, str] | None = None
+    ) -> list[dict[str, str]]:
+        """Run a query and return a list of dicts (one per row)."""
+        with self.engine.begin() as conn:
+            result = conn.execute(text(query), params or {})
+            if result.returns_rows:
+                dc = [dict(row) for row in result.mappings()]
+            else:
+                dc = []
+        return dc
+
+
+def tsql_nstr(s) -> str:
+    """Make a safe NVARCHAR literal (N'...') or NULL."""
+    if s is None:
+        return 'NULL'
+    # double single quotes inside the literal
+    return "N'{}'".format(str(s).replace("'", "''"))

al_data_utils/tg_utils/__init__.py

@@ -0,0 +1,3 @@
+from .tg_utils import (TelegramBot, TelegramBotException)
+
+__all__ = ['TelegramBot', 'TelegramBotException']

al_data_utils/tg_utils/tg_utils.py

@@ -0,0 +1,45 @@
+from typing import Union
+import requests
+
+
+class TelegramBot:
+    """Telegram Bot API wrapper
+
+    Examples:
+        >>> TelegramBot('YOuRAwEsomeBOtToKen', '@myprettydebugchat').send_message('Hi, darling')
+        >>> TelegramBot('YOuRAwEsomeBOtToKen').send_message('Hi, darling', chat_id=-1762374628374)
+    """
+
+    API_ENDPOINT = 'https://api.telegram.org/bot{}/'
+
+    def __init__(self, token: str, default_chat_id: Union[int, str] = None):
+        self.token = token
+        self._base_url = TelegramBot.API_ENDPOINT.format(token)
+        self.default_chat_id = default_chat_id
+
+    def send_message(self, message: str, chat_id: Union[int, str] = None):
+        method = 'sendMessage'
+
+        response = requests.post(
+            url='https://api.telegram.org/bot{0}/{1}'.format(self.token, method),
+            data={'chat_id': chat_id or self.default_chat_id, 'text': message},
+        ).json()
+
+        if not response.get('ok'):
+            raise TelegramBotException(response)
+
+    def on_fail_callback(self, context, chat_id: Union[int, str] = None):
+        message = f"""
+😡 Task has failed.
+Task: {context.get('task_instance').task_id}
+DAG: {context.get('task_instance').dag_id}
+Execution Time: {context.get('execution_date')}
+Exception: {str(context.get('exception'))[:255]}
+"""
+
+        self.send_message(message=message, chat_id=chat_id or self.default_chat_id)
+
+
+class TelegramBotException(Exception):
+    def __init__(self, *args, **kwargs):
+        super().__init__((args, kwargs))

al_data_utils-0.3.1.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: al-data-utils
+Version: 0.3.1
+Summary: Reusable utilities for data engineering (Airflow, Azure, Snowflake, SQL, config).
+Author-email: AL Data Labs <pypi@aldatalabs.com>
+License-Expression: MIT
+Project-URL: Homepage, https://aldatalabs.com
+Keywords: airflow,data-engineering,azure,snowflake,sql
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# al-data-utils
+
+Reusable Python utilities for data and automation workflows.
+
+This repository contains independent utility modules for sync operations, git automation, SQL work, logging helpers, and MSSQL schema snapshot generation.
+
+## Python and Setup
+
+- Python: 3.10+
+- Packaging: setuptools (src layout)
+
+Install locally in editable mode:
+
+```bash
+pip install -e .
+```
+
+## Project Structure
+
+- src/al_data_utils
+- examples
+- development_guides
+- tools
+
+Main utility groups under src/al_data_utils:
+
+- airflow_utils
+- backup_utils
+- config_utils
+- files_sync_utils
+- geo_utils
+- git_utils
+- logging_utils
+- ones_api_utils
+- sql_utils
+- tg_utils
+
+## Examples
+
+Runnable examples are available in the `examples` folder for the main utility groups.
+Use them as reference implementations for local scripts and automation jobs.
+
+## MSSQL Schema Snapshot
+
+The snapshot tool exports SQL objects from MSSQL into a filesystem layout and syncs staging output to destination folders.
+
+Current behavior highlights:
+
+- Supports single DB and multi-DB runs in one execution.
+- Always writes outputs into per-DB folders.
+- Uses staging first, then syncs to final output.
+- Supports cleanup of staging folders.
+- Supports sync log retention cleanup.
+- Supports include and exclude filters per object type.
+- Supports DataGrip template override files.
+
+Output shape:
+
+```text
+<MSSQL_OUT_DIR>/<DatabaseName>/schemas/<schema>/
+	tables/
+	views/
+	routines/
+	sequences/
+	synonyms/
+```
+
+### Snapshot Environment Variables
+
+Core connection and output:
+
+- MSSQL_OUT_DIR
+- MSSQL_SERVER
+- MSSQL_DATABASE
+- MSSQL_DATABASES
+- MSSQL_AUTH_MODE
+- MSSQL_USER
+- MSSQL_PASSWORD
+- MSSQL_DRIVER
+
+Snapshot behavior:
+
+- MSSQL_ENABLE_TABLE_DEFINITIONS
+- MSSQL_ENABLE_INDEXES
+- MSSQL_ENABLE_FOREIGN_KEYS
+- MSSQL_ENABLE_VIEWS
+- MSSQL_ENABLE_STORED_PROCEDURES
+- MSSQL_ENABLE_FUNCTIONS
+- MSSQL_ENABLE_SEQUENCES
+- MSSQL_ENABLE_SYNONYMS
+- MSSQL_CLEANUP_STAGING
+- MSSQL_SYNC_LOG_RETENTION_DAYS
+
+Filters:
+
+- MSSQL_INCLUDE_SCHEMAS
+- MSSQL_EXCLUDE_SCHEMAS
+- MSSQL_INCLUDE_TABLES
+- MSSQL_EXCLUDE_TABLES
+- MSSQL_INCLUDE_VIEWS
+- MSSQL_EXCLUDE_VIEWS
+- MSSQL_INCLUDE_STORED_PROCEDURES
+- MSSQL_EXCLUDE_STORED_PROCEDURES
+- MSSQL_INCLUDE_FUNCTIONS
+- MSSQL_EXCLUDE_FUNCTIONS
+- MSSQL_INCLUDE_SEQUENCES
+- MSSQL_EXCLUDE_SEQUENCES
+- MSSQL_INCLUDE_SYNONYMS
+- MSSQL_EXCLUDE_SYNONYMS
+
+Notes:
+
+- If MSSQL_DATABASES is set, it is treated as a comma-separated list.
+- If MSSQL_DATABASES is empty, MSSQL_DATABASE is used.
+- If MSSQL_DATABASE contains commas, it is also treated as a list for backward compatibility.
+
+## File Sync Utilities
+
+`files_sync_utils` provides:
+
+- Inventory building
+- Plan generation
+- Copy and update execution
+- Extra destination cleanup rules
+- Activity CSV logging
+- Log retention cleanup
+
+## Git Utilities
+
+`git_utils` wraps common git automation operations with consistent behavior and error handling.
+
+## Development Guides
+
+- development_guides/dev_guide.txt
+- development_guides/auth_key_guide.txt
+
+These guides contain release flow notes and auth-related instructions.
+
+## Changelog
+
+See CHANGELOG.md for release notes.

al_data_utils-0.3.1.dist-info/RECORD

@@ -0,0 +1,60 @@
+al_data_utils/__init__.py,sha256=l5Mdphl5Gh_pIo8qYMTyUxTQAdkvuiGkCQwXPfkea9o,180
+al_data_utils/airflow_utils/__init__.py,sha256=Yq-Yy9rNmm4NTC2Qo0XLT-j9-b4h4pKrkoXY6l1uOcI,283
+al_data_utils/airflow_utils/airflow_utils.py,sha256=fcCRzVogkTDBnnRovX8_3Qv4pnkPnoBRiOVNq-B-Dac,2470
+al_data_utils/azure_as_utils/__init__.py,sha256=AYWuh37QwiPdStM7uHvW2NFzjR1cIBxScSOAh8F9WpM,789
+al_data_utils/azure_as_utils/auth.py,sha256=2NBJN6TOV5jUpahcj5uqw3LEQHA3iWyiwQyeDKBsvI8,2825
+al_data_utils/azure_as_utils/azure_as_utils.py,sha256=mtkw47RDHCQ9ppFafdhn-p9rqL8HvHAvkCcCQGML-8U,8875
+al_data_utils/azure_as_utils/client.py,sha256=GJGAb6lj5AuyKRAyVIAZ4kdAlfI5A7VKZea0MqorB6A,6162
+al_data_utils/azure_as_utils/errors.py,sha256=IYU20hNhGtvoM_6LB9bYl1LOsh6Jn9TB_3hJP10TgYg,2513
+al_data_utils/azure_as_utils/models.py,sha256=5Q9IvWFh5hgAbhs2INg9dI7NFdOccbh0AT_btJedIw0,10299
+al_data_utils/azure_as_utils/poller.py,sha256=-JQSb5PEgk-AsbQTGX0zpU8iRUo6Wdpfcri9XnSSBdA,4626
+al_data_utils/backup_utils/__init__.py,sha256=ivVRrdutosWUQ6az7qYaPKsOy1UNS9TLE9ixbaV4PjI,381
+al_data_utils/backup_utils/mssql/dacpac/__init__.py,sha256=_tuqsMspDnkc8vM2BLIjyBe0dOwVonQcyYSlwupLihY,77
+al_data_utils/backup_utils/mssql/dacpac/sqlpackage.py,sha256=NTTZjRBn_oL2HStOeGexTzx0ianDYvAAC4Ch6FEwWjg,6227
+al_data_utils/backup_utils/mssql/schema_snapshot/__init__.py,sha256=ek95VFS_psM3kpiC3g3oIJTBBebXSk4uPpeABN-Vgfg,215
+al_data_utils/backup_utils/mssql/schema_snapshot/config.py,sha256=HUGKDiz690qR1IRywmwR3S6zU1XBJYOL7ZqRShghU6M,5451
+al_data_utils/backup_utils/mssql/schema_snapshot/snapshot_processor.py,sha256=9lE7Naq2hl6PA0HUftlljx86VxKbZ7ZoW1Ql_2E68aE,26635
+al_data_utils/backup_utils/mssql/schema_snapshot/emit/__init__.py,sha256=qlHd-Kndr0IDI8iJNBBp_lshNkeGdVGDx3pBPdXUbKo,288
+al_data_utils/backup_utils/mssql/schema_snapshot/emit/foreign_keys.py,sha256=k2IQp4ByXavacvOvYXGc2ZXG64TROuHSUV_qVVv93to,1056
+al_data_utils/backup_utils/mssql/schema_snapshot/emit/indexes.py,sha256=gF8gEY09jsaVlpEt2ro6qikBaxLbqicHlQC_tVGf3Qw,1069
+al_data_utils/backup_utils/mssql/schema_snapshot/emit/sql_objects.py,sha256=47QVpNg2epyanB3EXT_BiAl_5Phy9pi2N0LRtbXrw_o,434
+al_data_utils/backup_utils/mssql/schema_snapshot/emit/tables.py,sha256=0S6V_1SvSKcA4nOr09do_6te1_hIGhTSvjDnSpcbDhA,4168
+al_data_utils/backup_utils/mssql/schema_snapshot/introspect/__init__.py,sha256=d6Yvh-6JO9QrxAI8N_WFLRd-a0XSmILnVNUNEGsVMBU,501
+al_data_utils/backup_utils/mssql/schema_snapshot/introspect/foreign_keys.py,sha256=-EyeL5YRPDuuWoG6caZfGS7IF3j0QhTQ84rv4NTgu2g,6149
+al_data_utils/backup_utils/mssql/schema_snapshot/introspect/functions.py,sha256=nZK9bqBwjM4uBSaKt_Gs8daj-NOmGLRRDUwSH-ygFrw,4194
+al_data_utils/backup_utils/mssql/schema_snapshot/introspect/indexes.py,sha256=MUs728kqTaGCb4l7fIl0lSGNNwpPa0Bbgjt0k-dqMR0,6534
+al_data_utils/backup_utils/mssql/schema_snapshot/introspect/sequences.py,sha256=Ps22XFiMUts2Ye7yV1vxzy6TxbGRUUnM2MPdS83mQpI,5847
+al_data_utils/backup_utils/mssql/schema_snapshot/introspect/stored_procedures.py,sha256=shdi_OZeOMXtUwwGso1msqMGGoI8gXjalw8ZK570PDU,10667
+al_data_utils/backup_utils/mssql/schema_snapshot/introspect/synonyms.py,sha256=rcyT82ddwvQd7RaFVZbnhkeaQPScRDwRLTbmAkV7fgY,4320
+al_data_utils/backup_utils/mssql/schema_snapshot/introspect/tables.py,sha256=5H7QgAyiUWTdP2DVhCtzLYETR_V6ReFitSdmkJxEfzM,8926
+al_data_utils/backup_utils/mssql/schema_snapshot/introspect/views.py,sha256=O3B6FQWmRr1BuYrNq7bE1PK69FjUlPbLqbLtH5ECi3g,8087
+al_data_utils/backup_utils/mssql/schema_snapshot/io/__init__.py,sha256=om0ki99fKptoalzw-It_bHUqGjAaJRe9jJL44io5qPU,275
+al_data_utils/backup_utils/mssql/schema_snapshot/io/layout.py,sha256=52u6V-vwg-PDBQxiLyTDb7G2dtQqE1bfsM38gvmDId8,624
+al_data_utils/backup_utils/mssql/schema_snapshot/io/writer.py,sha256=BiESwNLW_yZ9V6TceUcV0DOwV7ShesctfL3f77K190E,1071
+al_data_utils/backup_utils/mssql/schema_snapshot/models/__init__.py,sha256=Y6aIhnMlhjpuAQPFDe4buJxyfSBWRZbMCNvwHSIOvN0,353
+al_data_utils/backup_utils/mssql/schema_snapshot/models/foreign_key_def.py,sha256=tFB5_66UQg0EI6xqSaCNw90aNoDlhDS7DUAJD2ga5Q4,487
+al_data_utils/backup_utils/mssql/schema_snapshot/models/index_def.py,sha256=hjnKyacS3XCynXXh3lLhWv0aG6aPQNzF0UK2MIhIto4,518
+al_data_utils/backup_utils/mssql/schema_snapshot/models/sql_object_def.py,sha256=ehsn5Y5ZBK6i1FfiwXdU_HtMGiVUOYEiFOU1FnNkuds,257
+al_data_utils/backup_utils/mssql/schema_snapshot/models/table_column_def.py,sha256=WH9nipBAXwjWz3yjbz12Hh0dn0xzckrEmHuRkuPyRrU,603
+al_data_utils/backup_utils/mssql/schema_snapshot/models/table_def.py,sha256=OPZ5ngP7XRAituFNQa0jaW6jVz_wtUziPfiZ9zJrl2k,453
+al_data_utils/backup_utils/mssql/scripter/__init__.py,sha256=RkwDreYTHuYloJr2wpjPY_Ggp2LmhLrkanUtCKFwyv8,52
+al_data_utils/config_utils/__init__.py,sha256=HrzEu11bJhikSvP6seI3dR1ZJnm4bqtNg8G930MLWLo,109
+al_data_utils/config_utils/config_utils.py,sha256=DMiIK7HMdLUmLAUrrd36iYks0WUHXZsB7idxjyFKLhA,1005
+al_data_utils/files_sync_utils/__init__.py,sha256=WzoysPTOXc6s8VZzDRnr95XZ5hj8vPULQsLr08momiU,268
+al_data_utils/files_sync_utils/files_sync_utils.py,sha256=ehor1N634BqPLTZKxCPeM9a_tJNpjHicHq9q4n_dGTQ,19724
+al_data_utils/geo_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+al_data_utils/git_utils/__init__.py,sha256=T26XLhi4BTpFyFpg0NNF4H7sbE5P6MGJ647mpWJROxs,487
+al_data_utils/git_utils/git_utils.py,sha256=ovfCy9dxvA1pMe5e4sVNzjK8U0j8UHvNKgoeqnI1hF0,4213
+al_data_utils/logging_utils/__init__.py,sha256=HsgS_gpsmsF4QOVacINzIsVHxVuAGpVWyXGI6gn5st0,129
+al_data_utils/logging_utils/logging_utils.py,sha256=d-HB6fRDYqs3r7faFoJ9qt4yO_xEbS2H9ulE6K4JcwQ,992
+al_data_utils/ones_api_utils/__init__.py,sha256=qSm5LIycuuyVs2q8AMM82dJbksLhLnIlfZYsYZPxYVI,72
+al_data_utils/ones_api_utils/ones_api_utils.py,sha256=20CW5YdrWzObL8oFcdkvMnDQ8CN0gOcCAoeKd56zLwk,1984
+al_data_utils/sql_utils/__init__.py,sha256=UF73sf9UD7hU5DIGEuY7x2GhqDYVIo9mpyb45vVUJqY,125
+al_data_utils/sql_utils/sql_utils.py,sha256=wAH-BbFLb6x8uL5B6xE3xzM2giUt6qHcv1buV0tlbcQ,6375
+al_data_utils/tg_utils/__init__.py,sha256=GqloghgtS6OgL6IRnqXTvYFs7FgxnL6vMcSMGcmyEtw,110
+al_data_utils/tg_utils/tg_utils.py,sha256=eyk9v__Mh5pSQJp_9GHfmOQw1i9C7mdKYISI6-7I0TM,1551
+al_data_utils-0.3.1.dist-info/licenses/LICENSE,sha256=FSoDw09XQtrZEbEgid_0dBku6vuuPj3r7XPxcTklOfo,1090
+al_data_utils-0.3.1.dist-info/METADATA,sha256=k8E6oLadDmhS7EQ140u7cxsAZqn-xN5W7rbvK2GktXA,3827
+al_data_utils-0.3.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+al_data_utils-0.3.1.dist-info/top_level.txt,sha256=Ade88LWXWws-LCIeYmUHHRRN6Eq8MTM0Di5BXxA6ir0,14
+al_data_utils-0.3.1.dist-info/RECORD,,