sqlsaber 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

sqlsaber/database/connection.py

@@ -1,535 +0,0 @@
-"""Database connection management."""
-
-import asyncio
-import ssl
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Any
-from urllib.parse import parse_qs, urlparse
-
-import aiomysql
-import aiosqlite
-import asyncpg
-import duckdb
-
-# Default query timeout to prevent runaway queries
-DEFAULT_QUERY_TIMEOUT = 30.0  # seconds
-
-
-class QueryTimeoutError(RuntimeError):
-    """Exception raised when a query exceeds its timeout."""
-
-    def __init__(self, seconds: float):
-        self.timeout = seconds
-        super().__init__(f"Query exceeded timeout of {seconds}s")
-
-
-class BaseDatabaseConnection(ABC):
-    """Abstract base class for database connections."""
-
-    def __init__(self, connection_string: str):
-        self.connection_string = connection_string
-        self._pool = None
-
-    @abstractmethod
-    async def get_pool(self):
-        """Get or create connection pool."""
-        pass
-
-    @abstractmethod
-    async def close(self):
-        """Close the connection pool."""
-        pass
-
-    @abstractmethod
-    async def execute_query(
-        self, query: str, *args, timeout: float | None = None
-    ) -> list[dict[str, Any]]:
-        """Execute a query and return results as list of dicts.
-
-        All queries run in a transaction that is rolled back at the end,
-        ensuring no changes are persisted to the database.
-
-        Args:
-            query: SQL query to execute
-            *args: Query parameters
-            timeout: Query timeout in seconds (overrides default_timeout)
-        """
-        pass
-
-
-class PostgreSQLConnection(BaseDatabaseConnection):
-    """PostgreSQL database connection using asyncpg."""
-
-    def __init__(self, connection_string: str):
-        super().__init__(connection_string)
-        self._pool: asyncpg.Pool | None = None
-        self._ssl_context = self._create_ssl_context()
-
-    def _create_ssl_context(self) -> ssl.SSLContext | None:
-        """Create SSL context from connection string parameters."""
-        parsed = urlparse(self.connection_string)
-        if not parsed.query:
-            return None
-
-        params = parse_qs(parsed.query)
-        ssl_mode = params.get("sslmode", [None])[0]
-
-        if not ssl_mode or ssl_mode == "disable":
-            return None
-
-        # Create SSL context based on mode
-        if ssl_mode in ["require", "verify-ca", "verify-full"]:
-            ssl_context = ssl.create_default_context()
-
-            # Configure certificate verification
-            if ssl_mode == "require":
-                ssl_context.check_hostname = False
-                ssl_context.verify_mode = ssl.CERT_NONE
-            elif ssl_mode == "verify-ca":
-                ssl_context.check_hostname = False
-                ssl_context.verify_mode = ssl.CERT_REQUIRED
-            elif ssl_mode == "verify-full":
-                ssl_context.check_hostname = True
-                ssl_context.verify_mode = ssl.CERT_REQUIRED
-
-            # Load certificates if provided
-            ssl_ca = params.get("sslrootcert", [None])[0]
-            ssl_cert = params.get("sslcert", [None])[0]
-            ssl_key = params.get("sslkey", [None])[0]
-
-            if ssl_ca:
-                ssl_context.load_verify_locations(ssl_ca)
-
-            if ssl_cert and ssl_key:
-                ssl_context.load_cert_chain(ssl_cert, ssl_key)
-
-            return ssl_context
-
-        return None
-
-    async def get_pool(self) -> asyncpg.Pool:
-        """Get or create connection pool."""
-        if self._pool is None:
-            # Create pool with SSL context if configured
-            if self._ssl_context:
-                self._pool = await asyncpg.create_pool(
-                    self.connection_string,
-                    min_size=1,
-                    max_size=10,
-                    ssl=self._ssl_context,
-                )
-            else:
-                self._pool = await asyncpg.create_pool(
-                    self.connection_string, min_size=1, max_size=10
-                )
-        return self._pool
-
-    async def close(self):
-        """Close the connection pool."""
-        if self._pool:
-            await self._pool.close()
-            self._pool = None
-
-    async def execute_query(
-        self, query: str, *args, timeout: float | None = None
-    ) -> list[dict[str, Any]]:
-        """Execute a query and return results as list of dicts.
-
-        All queries run in a transaction that is rolled back at the end,
-        ensuring no changes are persisted to the database.
-        """
-        effective_timeout = timeout or DEFAULT_QUERY_TIMEOUT
-        pool = await self.get_pool()
-
-        async with pool.acquire() as conn:
-            # Start a transaction that we'll always rollback
-            transaction = conn.transaction()
-            await transaction.start()
-
-            try:
-                # Set server-side timeout if specified
-                if effective_timeout:
-                    await conn.execute(
-                        f"SET LOCAL statement_timeout = {int(effective_timeout * 1000)}"
-                    )
-
-                # Execute query with client-side timeout
-                if effective_timeout:
-                    rows = await asyncio.wait_for(
-                        conn.fetch(query, *args), timeout=effective_timeout
-                    )
-                else:
-                    rows = await conn.fetch(query, *args)
-
-                return [dict(row) for row in rows]
-            except asyncio.TimeoutError as exc:
-                raise QueryTimeoutError(effective_timeout or 0) from exc
-            finally:
-                # Always rollback to ensure no changes are committed
-                await transaction.rollback()
-
-
-class MySQLConnection(BaseDatabaseConnection):
-    """MySQL database connection using aiomysql."""
-
-    def __init__(self, connection_string: str):
-        super().__init__(connection_string)
-        self._pool: aiomysql.Pool | None = None
-        self._parse_connection_string()
-
-    def _parse_connection_string(self):
-        """Parse MySQL connection string into components."""
-        parsed = urlparse(self.connection_string)
-        self.host = parsed.hostname or "localhost"
-        self.port = parsed.port or 3306
-        self.database = parsed.path.lstrip("/") if parsed.path else ""
-        self.user = parsed.username or ""
-        self.password = parsed.password or ""
-
-        # Parse SSL parameters
-        self.ssl_params = {}
-        if parsed.query:
-            params = parse_qs(parsed.query)
-
-            ssl_mode = params.get("ssl_mode", [None])[0]
-            if ssl_mode:
-                # Map SSL modes to aiomysql SSL parameters
-                if ssl_mode.upper() == "DISABLED":
-                    self.ssl_params["ssl"] = None
-                elif ssl_mode.upper() in [
-                    "PREFERRED",
-                    "REQUIRED",
-                    "VERIFY_CA",
-                    "VERIFY_IDENTITY",
-                ]:
-                    ssl_context = ssl.create_default_context()
-
-                    if ssl_mode.upper() == "REQUIRED":
-                        ssl_context.check_hostname = False
-                        ssl_context.verify_mode = ssl.CERT_NONE
-                    elif ssl_mode.upper() == "VERIFY_CA":
-                        ssl_context.check_hostname = False
-                        ssl_context.verify_mode = ssl.CERT_REQUIRED
-                    elif ssl_mode.upper() == "VERIFY_IDENTITY":
-                        ssl_context.check_hostname = True
-                        ssl_context.verify_mode = ssl.CERT_REQUIRED
-
-                    # Load certificates if provided
-                    ssl_ca = params.get("ssl_ca", [None])[0]
-                    ssl_cert = params.get("ssl_cert", [None])[0]
-                    ssl_key = params.get("ssl_key", [None])[0]
-
-                    if ssl_ca:
-                        ssl_context.load_verify_locations(ssl_ca)
-
-                    if ssl_cert and ssl_key:
-                        ssl_context.load_cert_chain(ssl_cert, ssl_key)
-
-                    self.ssl_params["ssl"] = ssl_context
-
-    async def get_pool(self) -> aiomysql.Pool:
-        """Get or create connection pool."""
-        if self._pool is None:
-            pool_kwargs = {
-                "host": self.host,
-                "port": self.port,
-                "user": self.user,
-                "password": self.password,
-                "db": self.database,
-                "minsize": 1,
-                "maxsize": 10,
-                "autocommit": False,
-            }
-
-            # Add SSL parameters if configured
-            pool_kwargs.update(self.ssl_params)
-
-            self._pool = await aiomysql.create_pool(**pool_kwargs)
-        return self._pool
-
-    async def close(self):
-        """Close the connection pool."""
-        if self._pool:
-            self._pool.close()
-            await self._pool.wait_closed()
-            self._pool = None
-
-    async def execute_query(
-        self, query: str, *args, timeout: float | None = None
-    ) -> list[dict[str, Any]]:
-        """Execute a query and return results as list of dicts.
-
-        All queries run in a transaction that is rolled back at the end,
-        ensuring no changes are persisted to the database.
-        """
-        effective_timeout = timeout or DEFAULT_QUERY_TIMEOUT
-        pool = await self.get_pool()
-
-        async with pool.acquire() as conn:
-            async with conn.cursor(aiomysql.DictCursor) as cursor:
-                # Start transaction
-                await conn.begin()
-                try:
-                    # Set server-side timeout if specified
-                    if effective_timeout:
-                        await cursor.execute(
-                            f"SET SESSION MAX_EXECUTION_TIME = {int(effective_timeout * 1000)}"
-                        )
-
-                    # Execute query with client-side timeout
-                    if effective_timeout:
-                        await asyncio.wait_for(
-                            cursor.execute(query, args if args else None),
-                            timeout=effective_timeout,
-                        )
-                        rows = await asyncio.wait_for(
-                            cursor.fetchall(), timeout=effective_timeout
-                        )
-                    else:
-                        await cursor.execute(query, args if args else None)
-                        rows = await cursor.fetchall()
-
-                    return [dict(row) for row in rows]
-                except asyncio.TimeoutError as exc:
-                    raise QueryTimeoutError(effective_timeout or 0) from exc
-                finally:
-                    # Always rollback to ensure no changes are committed
-                    await conn.rollback()
-
-
-class SQLiteConnection(BaseDatabaseConnection):
-    """SQLite database connection using aiosqlite."""
-
-    def __init__(self, connection_string: str):
-        super().__init__(connection_string)
-        # Extract database path from sqlite:///path format
-        self.database_path = connection_string.replace("sqlite:///", "")
-
-    async def get_pool(self):
-        """SQLite doesn't use connection pooling, return database path."""
-        return self.database_path
-
-    async def close(self):
-        """SQLite connections are created per query, no persistent pool to close."""
-        pass
-
-    async def execute_query(
-        self, query: str, *args, timeout: float | None = None
-    ) -> list[dict[str, Any]]:
-        """Execute a query and return results as list of dicts.
-
-        All queries run in a transaction that is rolled back at the end,
-        ensuring no changes are persisted to the database.
-        """
-        effective_timeout = timeout or DEFAULT_QUERY_TIMEOUT
-
-        async with aiosqlite.connect(self.database_path) as conn:
-            # Enable row factory for dict-like access
-            conn.row_factory = aiosqlite.Row
-
-            # Start transaction
-            await conn.execute("BEGIN")
-            try:
-                # Execute query with client-side timeout (SQLite has no server-side timeout)
-                if effective_timeout:
-                    cursor = await asyncio.wait_for(
-                        conn.execute(query, args if args else ()),
-                        timeout=effective_timeout,
-                    )
-                    rows = await asyncio.wait_for(
-                        cursor.fetchall(), timeout=effective_timeout
-                    )
-                else:
-                    cursor = await conn.execute(query, args if args else ())
-                    rows = await cursor.fetchall()
-
-                return [dict(row) for row in rows]
-            except asyncio.TimeoutError as exc:
-                raise QueryTimeoutError(effective_timeout or 0) from exc
-            finally:
-                # Always rollback to ensure no changes are committed
-                await conn.rollback()
-
-
-def _execute_duckdb_transaction(
-    conn: duckdb.DuckDBPyConnection, query: str, args: tuple[Any, ...]
-) -> list[dict[str, Any]]:
-    """Run a DuckDB query inside a transaction and return list of dicts."""
-    conn.execute("BEGIN TRANSACTION")
-    try:
-        if args:
-            conn.execute(query, args)
-        else:
-            conn.execute(query)
-
-        if conn.description is None:
-            rows: list[dict[str, Any]] = []
-        else:
-            columns = [col[0] for col in conn.description]
-            data = conn.fetchall()
-            rows = [dict(zip(columns, row)) for row in data]
-
-        conn.execute("ROLLBACK")
-        return rows
-    except Exception:
-        conn.execute("ROLLBACK")
-        raise
-
-
-class CSVConnection(BaseDatabaseConnection):
-    """CSV file connection using DuckDB per query."""
-
-    def __init__(self, connection_string: str):
-        super().__init__(connection_string)
-
-        raw_path = connection_string.replace("csv:///", "", 1)
-        self.csv_path = raw_path.split("?", 1)[0]
-
-        self.delimiter = ","
-        self.encoding = "utf-8"
-        self.has_header = True
-
-        parsed = urlparse(connection_string)
-        if parsed.query:
-            params = parse_qs(parsed.query)
-            self.delimiter = params.get("delimiter", [self.delimiter])[0]
-            self.encoding = params.get("encoding", [self.encoding])[0]
-            self.has_header = params.get("header", ["true"])[0].lower() == "true"
-
-        self.table_name = Path(self.csv_path).stem or "csv_table"
-
-    async def get_pool(self):
-        """CSV connections do not maintain a pool."""
-        return None
-
-    async def close(self):
-        """No persistent resources to close for CSV connections."""
-        pass
-
-    def _quote_identifier(self, identifier: str) -> str:
-        escaped = identifier.replace('"', '""')
-        return f'"{escaped}"'
-
-    def _quote_literal(self, value: str) -> str:
-        escaped = value.replace("'", "''")
-        return f"'{escaped}'"
-
-    def _normalized_encoding(self) -> str | None:
-        encoding = (self.encoding or "").strip()
-        if not encoding or encoding.lower() == "utf-8":
-            return None
-        return encoding.replace("-", "").replace("_", "").upper()
-
-    def _create_view(self, conn: duckdb.DuckDBPyConnection) -> None:
-        header_literal = "TRUE" if self.has_header else "FALSE"
-        option_parts = [f"HEADER={header_literal}"]
-
-        if self.delimiter:
-            option_parts.append(f"DELIM={self._quote_literal(self.delimiter)}")
-
-        encoding = self._normalized_encoding()
-        if encoding:
-            option_parts.append(f"ENCODING={self._quote_literal(encoding)}")
-
-        options_sql = ""
-        if option_parts:
-            options_sql = ", " + ", ".join(option_parts)
-
-        base_relation_sql = (
-            f"read_csv_auto({self._quote_literal(self.csv_path)}{options_sql})"
-        )
-
-        create_view_sql = (
-            f"CREATE VIEW {self._quote_identifier(self.table_name)} AS "
-            f"SELECT * FROM {base_relation_sql}"
-        )
-        conn.execute(create_view_sql)
-
-    async def execute_query(
-        self, query: str, *args, timeout: float | None = None
-    ) -> list[dict[str, Any]]:
-        effective_timeout = timeout or DEFAULT_QUERY_TIMEOUT
-        args_tuple = tuple(args) if args else tuple()
-
-        def _run_query() -> list[dict[str, Any]]:
-            conn = duckdb.connect(":memory:")
-            try:
-                self._create_view(conn)
-                return _execute_duckdb_transaction(conn, query, args_tuple)
-            finally:
-                conn.close()
-
-        try:
-            return await asyncio.wait_for(
-                asyncio.to_thread(_run_query), timeout=effective_timeout
-            )
-        except asyncio.TimeoutError as exc:
-            raise QueryTimeoutError(effective_timeout or 0) from exc
-
-
-class DuckDBConnection(BaseDatabaseConnection):
-    """DuckDB database connection using duckdb Python API."""
-
-    def __init__(self, connection_string: str):
-        super().__init__(connection_string)
-        if connection_string.startswith("duckdb:///"):
-            db_path = connection_string.replace("duckdb:///", "", 1)
-        elif connection_string.startswith("duckdb://"):
-            db_path = connection_string.replace("duckdb://", "", 1)
-        else:
-            db_path = connection_string
-
-        self.database_path = db_path or ":memory:"
-
-    async def get_pool(self):
-        """DuckDB creates connections per query, return database path."""
-        return self.database_path
-
-    async def close(self):
-        """DuckDB connections are created per query, no persistent pool to close."""
-        pass
-
-    async def execute_query(
-        self, query: str, *args, timeout: float | None = None
-    ) -> list[dict[str, Any]]:
-        """Execute a query and return results as list of dicts.
-
-        All queries run in a transaction that is rolled back at the end,
-        ensuring no changes are persisted to the database.
-        """
-        effective_timeout = timeout or DEFAULT_QUERY_TIMEOUT
-
-        args_tuple = tuple(args) if args else tuple()
-
-        def _run_query() -> list[dict[str, Any]]:
-            conn = duckdb.connect(self.database_path)
-            try:
-                return _execute_duckdb_transaction(conn, query, args_tuple)
-            finally:
-                conn.close()
-
-        try:
-            return await asyncio.wait_for(
-                asyncio.to_thread(_run_query), timeout=effective_timeout
-            )
-        except asyncio.TimeoutError as exc:
-            raise QueryTimeoutError(effective_timeout or 0) from exc
-
-
-def DatabaseConnection(connection_string: str) -> BaseDatabaseConnection:
-    """Factory function to create appropriate database connection based on connection string."""
-    if connection_string.startswith("postgresql://"):
-        return PostgreSQLConnection(connection_string)
-    elif connection_string.startswith("mysql://"):
-        return MySQLConnection(connection_string)
-    elif connection_string.startswith("sqlite:///"):
-        return SQLiteConnection(connection_string)
-    elif connection_string.startswith("duckdb://"):
-        return DuckDBConnection(connection_string)
-    elif connection_string.startswith("csv:///"):
-        return CSVConnection(connection_string)
-    else:
-        raise ValueError(
-            f"Unsupported database type in connection string: {connection_string}"
-        )

sqlsaber-0.25.0.dist-info/RECORD

@@ -1,47 +0,0 @@
-sqlsaber/__init__.py,sha256=HjS8ULtP4MGpnTL7njVY45NKV9Fi4e_yeYuY-hyXWQc,73
-sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
-sqlsaber/agents/__init__.py,sha256=i_MI2eWMQaVzGikKU71FPCmSQxNDKq36Imq1PrYoIPU,130
-sqlsaber/agents/base.py,sha256=EAuoj3vpWNqksudMd2lL1Fmx68Y91qNX6NyK1RjQ4-g,2679
-sqlsaber/agents/mcp.py,sha256=GcJTx7YDYH6aaxIADEIxSgcWAdWakUx395JIzVnf17U,768
-sqlsaber/agents/pydantic_ai_agent.py,sha256=qn-DnTGcdUzSEn9xBWwGhgtifYxZ_NEo8XPePnl1StE,7154
-sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
-sqlsaber/cli/auth.py,sha256=jTsRgbmlGPlASSuIKmdjjwfqtKvjfKd_cTYxX0-QqaQ,7400
-sqlsaber/cli/commands.py,sha256=NyBDr5qEnCOZrHEMGcEpHLXEWdlzEQW3D61NIrPi2fQ,8727
-sqlsaber/cli/completers.py,sha256=HsUPjaZweLSeYCWkAcgMl8FylQ1xjWBWYTEL_9F6xfU,6430
-sqlsaber/cli/database.py,sha256=93etjqiYAfH08jBe_OJpLMNKiu3H81G8O7CMB31MIIc,13424
-sqlsaber/cli/display.py,sha256=XuKiTWUw5k0U0P_f1K7zhDWX5KTO2DQVG0Q0XU9VEhs,16334
-sqlsaber/cli/interactive.py,sha256=lVOtONBeAmZxWdfkvdoVoX4POs_-C1YVs0jPxY9MoZs,13288
-sqlsaber/cli/memory.py,sha256=OufHFJFwV0_GGn7LvKRTJikkWhV1IwNIUDOxFPHXOaQ,7794
-sqlsaber/cli/models.py,sha256=ZewtwGQwhd9b-yxBAPKePolvI1qQG-EkmeWAGMqtWNQ,8986
-sqlsaber/cli/streaming.py,sha256=Eo5CNUgDGY1WYP90jwDA2aY7RefN-TfcStA6NyjUQTY,7076
-sqlsaber/cli/threads.py,sha256=ufDABlqndVJKd5COgSokcFRIKTgsGqXdHV84DVVm7MA,12743
-sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
-sqlsaber/config/api_keys.py,sha256=RqWQCko1tY7sES7YOlexgBH5Hd5ne_kGXHdBDNqcV2U,3649
-sqlsaber/config/auth.py,sha256=b5qB2h1doXyO9Bn8z0CcL8LAR2jF431gGXBGKLgTmtQ,2756
-sqlsaber/config/database.py,sha256=Yec6_0wdzq-ADblMNnbgvouYCimYOY_DWHT9oweaISc,11449
-sqlsaber/config/oauth_flow.py,sha256=A3bSXaBLzuAfXV2ZPA94m9NV33c2MyL6M4ii9oEkswQ,10291
-sqlsaber/config/oauth_tokens.py,sha256=C9z35hyx-PvSAYdC1LNf3rg9_wsEIY56hkEczelbad0,6015
-sqlsaber/config/providers.py,sha256=JFjeJv1K5Q93zWSlWq3hAvgch1TlgoF0qFa0KJROkKY,2957
-sqlsaber/config/settings.py,sha256=vgb_RXaM-7DgbxYDmWNw1cSyMqwys4j3qNCvM4bljwI,5586
-sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
-sqlsaber/database/connection.py,sha256=J3U08Qu7NQrmem0jPM5XKIHPmPJE927IiLhN8zA6oLo,19392
-sqlsaber/database/resolver.py,sha256=wSCcn__aCqwIfpt_LCjtW2Zgb8RpG5PlmwwZHli1q_U,3628
-sqlsaber/database/schema.py,sha256=9HXTb5O_nlS2aNDeyv7EXhX7_kN2hs6rbPnJ8fnLyWk,41260
-sqlsaber/mcp/__init__.py,sha256=COdWq7wauPBp5Ew8tfZItFzbcLDSEkHBJSMhxzy8C9c,112
-sqlsaber/mcp/mcp.py,sha256=X12oCMZYAtgJ7MNuh5cqz8y3lALrOzkXWcfpuY0Ijxk,3950
-sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
-sqlsaber/memory/manager.py,sha256=p3fybMVfH-E4ApT1ZRZUnQIWSk9dkfUPCyfkmA0HALs,2739
-sqlsaber/memory/storage.py,sha256=ne8szLlGj5NELheqLnI7zu21V8YS4rtpYGGC7tOmi-s,5745
-sqlsaber/threads/__init__.py,sha256=Hh3dIG1tuC8fXprREUpslCIgPYz8_6o7aRLx4yNeO48,139
-sqlsaber/threads/storage.py,sha256=rsUdxT4CR52D7xtGir9UlsFnBMk11jZeflzDrk2q4ME,11183
-sqlsaber/tools/__init__.py,sha256=x3YdmX_7P0Qq_HtZHAgfIVKTLxYqKk6oc4tGsujQWsc,586
-sqlsaber/tools/base.py,sha256=mHhvAj27BHmckyvuDLCPlAQdzABJyYxd9SJnaYAwwuA,1777
-sqlsaber/tools/enums.py,sha256=CH32mL-0k9ZA18911xLpNtsgpV6tB85TktMj6uqGz54,411
-sqlsaber/tools/instructions.py,sha256=X-x8maVkkyi16b6Tl0hcAFgjiYceZaSwyWTfmrvx8U8,9024
-sqlsaber/tools/registry.py,sha256=HWOQMsNIdL4XZS6TeNUyrL-5KoSDH6PHsWd3X66o-18,3211
-sqlsaber/tools/sql_tools.py,sha256=j4yRqfKokPFnZ_tEZPrWU5WStDc3Mexo1fWZ8KsmUjQ,9965
-sqlsaber-0.25.0.dist-info/METADATA,sha256=9Q2AsBv4I78FLo8Uezmnv_fCch3jIKgv1gzBBm1cVB4,6243
-sqlsaber-0.25.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.25.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
-sqlsaber-0.25.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.25.0.dist-info/RECORD,,