sqlsaber 0.14.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

sqlsaber/tools/sql_tools.py

@@ -0,0 +1,275 @@
+"""SQL-related tools for database operations."""
+
+import json
+from typing import Any
+
+from sqlsaber.database.connection import BaseDatabaseConnection
+from sqlsaber.database.schema import SchemaManager
+
+from .base import Tool
+from .enums import ToolCategory, WorkflowPosition
+from .registry import register_tool
+
+
+class SQLTool(Tool):
+    """Base class for SQL tools that need database access."""
+
+    def __init__(self, db_connection: BaseDatabaseConnection | None = None):
+        """Initialize with optional database connection."""
+        super().__init__()
+        self.db = db_connection
+        self.schema_manager = SchemaManager(db_connection) if db_connection else None
+
+    def set_connection(self, db_connection: BaseDatabaseConnection) -> None:
+        """Set the database connection after initialization."""
+        self.db = db_connection
+        self.schema_manager = SchemaManager(db_connection)
+
+    @property
+    def category(self) -> ToolCategory:
+        """SQL tools belong to the 'sql' category."""
+        return ToolCategory.SQL
+
+
+@register_tool
+class ListTablesTool(SQLTool):
+    """Tool for listing database tables."""
+
+    @property
+    def name(self) -> str:
+        return "list_tables"
+
+    @property
+    def description(self) -> str:
+        return "Get a list of all tables in the database with row counts. Use this first to discover available tables."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {},
+            "required": [],
+        }
+
+    def get_usage_instructions(self) -> str | None:
+        """Return usage instructions for this tool."""
+        return "ALWAYS start with 'list_tables' to see available tables and row counts. Use this first to discover available tables."
+
+    def get_priority(self) -> int:
+        """Return priority for tool ordering."""
+        return 10  # High priority - should be used first
+
+    def get_workflow_position(self) -> WorkflowPosition:
+        """Return workflow position."""
+        return WorkflowPosition.DISCOVERY
+
+    async def execute(self, **kwargs) -> str:
+        """List all tables in the database."""
+        if not self.db or not self.schema_manager:
+            return json.dumps({"error": "No database connection available"})
+
+        try:
+            tables_info = await self.schema_manager.list_tables()
+            return json.dumps(tables_info)
+        except Exception as e:
+            return json.dumps({"error": f"Error listing tables: {str(e)}"})
+
+
+@register_tool
+class IntrospectSchemaTool(SQLTool):
+    """Tool for introspecting database schema."""
+
+    @property
+    def name(self) -> str:
+        return "introspect_schema"
+
+    @property
+    def description(self) -> str:
+        return "Introspect database schema to understand table structures."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "table_pattern": {
+                    "type": "string",
+                    "description": "Optional pattern to filter tables (e.g., 'public.users', 'user%', '%order%')",
+                }
+            },
+            "required": [],
+        }
+
+    def get_usage_instructions(self) -> str | None:
+        """Return usage instructions for this tool."""
+        return "Use 'introspect_schema' with a table_pattern to get details ONLY for relevant tables. Use table patterns like 'sample%' or '%experiment%' to filter related tables."
+
+    def get_priority(self) -> int:
+        """Return priority for tool ordering."""
+        return 20  # Should come after list_tables
+
+    def get_workflow_position(self) -> WorkflowPosition:
+        """Return workflow position."""
+        return WorkflowPosition.ANALYSIS
+
+    async def execute(self, **kwargs) -> str:
+        """Introspect database schema."""
+        if not self.db or not self.schema_manager:
+            return json.dumps({"error": "No database connection available"})
+
+        try:
+            table_pattern = kwargs.get("table_pattern")
+            schema_info = await self.schema_manager.get_schema_info(table_pattern)
+
+            # Format the schema information
+            formatted_info = {}
+            for table_name, table_info in schema_info.items():
+                formatted_info[table_name] = {
+                    "columns": {
+                        col_name: {
+                            "type": col_info["data_type"],
+                            "nullable": col_info["nullable"],
+                            "default": col_info["default"],
+                        }
+                        for col_name, col_info in table_info["columns"].items()
+                    },
+                    "primary_keys": table_info["primary_keys"],
+                    "foreign_keys": [
+                        f"{fk['column']} -> {fk['references']['table']}.{fk['references']['column']}"
+                        for fk in table_info["foreign_keys"]
+                    ],
+                }
+
+            return json.dumps(formatted_info)
+        except Exception as e:
+            return json.dumps({"error": f"Error introspecting schema: {str(e)}"})
+
+
+@register_tool
+class ExecuteSQLTool(SQLTool):
+    """Tool for executing SQL queries."""
+
+    DEFAULT_LIMIT = 100
+
+    @property
+    def name(self) -> str:
+        return "execute_sql"
+
+    @property
+    def description(self) -> str:
+        return "Execute a SQL query against the database."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "SQL query to execute",
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": f"Maximum number of rows to return (default: {self.DEFAULT_LIMIT})",
+                    "default": self.DEFAULT_LIMIT,
+                },
+            },
+            "required": ["query"],
+        }
+
+    def get_usage_instructions(self) -> str | None:
+        """Return usage instructions for this tool."""
+        return "Execute SQL queries safely with automatic LIMIT clauses for SELECT statements. Only SELECT queries are permitted for security."
+
+    def get_priority(self) -> int:
+        """Return priority for tool ordering."""
+        return 30  # Should come after schema tools
+
+    def get_workflow_position(self) -> WorkflowPosition:
+        """Return workflow position."""
+        return WorkflowPosition.EXECUTION
+
+    async def execute(self, **kwargs) -> str:
+        """Execute a SQL query."""
+        if not self.db:
+            return json.dumps({"error": "No database connection available"})
+
+        query = kwargs.get("query")
+        if not query:
+            return json.dumps({"error": "No query provided"})
+
+        limit = kwargs.get("limit", self.DEFAULT_LIMIT)
+
+        try:
+            # Security check - only allow SELECT queries unless write is enabled
+            write_error = self._validate_write_operation(query)
+            if write_error:
+                return json.dumps({"error": write_error})
+
+            # Add LIMIT if not present and it's a SELECT query
+            query = self._add_limit_to_query(query, limit)
+
+            # Execute the query
+            results = await self.db.execute_query(query)
+
+            # Format results
+            actual_limit = limit if limit is not None else len(results)
+
+            return json.dumps(
+                {
+                    "success": True,
+                    "row_count": len(results),
+                    "results": results[:actual_limit],
+                    "truncated": len(results) > actual_limit,
+                }
+            )
+
+        except Exception as e:
+            error_msg = str(e)
+
+            # Provide helpful error messages
+            suggestions = []
+            if "column" in error_msg.lower() and "does not exist" in error_msg.lower():
+                suggestions.append(
+                    "Check column names using the schema introspection tool"
+                )
+            elif "table" in error_msg.lower() and "does not exist" in error_msg.lower():
+                suggestions.append(
+                    "Check table names using the schema introspection tool"
+                )
+            elif "syntax error" in error_msg.lower():
+                suggestions.append(
+                    "Review SQL syntax, especially JOIN conditions and WHERE clauses"
+                )
+
+            return json.dumps({"error": error_msg, "suggestions": suggestions})
+
+    def _validate_write_operation(self, query: str) -> str | None:
+        """Validate if a write operation is allowed."""
+        query_upper = query.strip().upper()
+
+        # Check for write operations
+        write_keywords = [
+            "INSERT",
+            "UPDATE",
+            "DELETE",
+            "DROP",
+            "CREATE",
+            "ALTER",
+            "TRUNCATE",
+        ]
+        is_write_query = any(query_upper.startswith(kw) for kw in write_keywords)
+
+        if is_write_query:
+            return (
+                "Write operations are not allowed. Only SELECT queries are permitted."
+            )
+
+        return None
+
+    def _add_limit_to_query(self, query: str, limit: int = 100) -> str:
+        """Add LIMIT clause to SELECT queries if not present."""
+        query_upper = query.strip().upper()
+        if query_upper.startswith("SELECT") and "LIMIT" not in query_upper:
+            return f"{query.rstrip(';')} LIMIT {limit};"
+        return query

sqlsaber/tools/visualization_tools.py

@@ -0,0 +1,144 @@
+"""Visualization tools for data plotting."""
+
+import json
+from typing import Any
+
+from uniplot import histogram, plot
+
+from .base import Tool
+from .enums import ToolCategory, WorkflowPosition
+from .registry import register_tool
+
+
+@register_tool
+class PlotDataTool(Tool):
+    """Tool for creating terminal plots using uniplot."""
+
+    @property
+    def name(self) -> str:
+        return "plot_data"
+
+    @property
+    def description(self) -> str:
+        return "Create a plot of query results."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "y_values": {
+                    "type": "array",
+                    "items": {"type": ["number", "null"]},
+                    "description": "Y-axis data points (required)",
+                },
+                "x_values": {
+                    "type": "array",
+                    "items": {"type": ["number", "null"]},
+                    "description": "X-axis data points (optional, will use indices if not provided)",
+                },
+                "plot_type": {
+                    "type": "string",
+                    "enum": ["line", "scatter", "histogram"],
+                    "description": "Type of plot to create (default: line)",
+                    "default": "line",
+                },
+                "title": {
+                    "type": "string",
+                    "description": "Title for the plot",
+                },
+                "x_label": {
+                    "type": "string",
+                    "description": "Label for X-axis",
+                },
+                "y_label": {
+                    "type": "string",
+                    "description": "Label for Y-axis",
+                },
+            },
+            "required": ["y_values"],
+        }
+
+    @property
+    def category(self) -> ToolCategory:
+        return ToolCategory.VISUALIZATION
+
+    def get_usage_instructions(self) -> str | None:
+        """Return usage instructions for this tool."""
+        return "Create terminal plots from query results when visualization would enhance understanding of the data."
+
+    def get_priority(self) -> int:
+        """Return priority for tool ordering."""
+        return 40  # Should come after SQL execution
+
+    def get_workflow_position(self) -> WorkflowPosition:
+        """Return workflow position."""
+        return WorkflowPosition.VISUALIZATION
+
+    async def execute(self, **kwargs) -> str:
+        """Create a terminal plot."""
+        y_values = kwargs.get("y_values", [])
+        x_values = kwargs.get("x_values")
+        plot_type = kwargs.get("plot_type", "line")
+        title = kwargs.get("title")
+        x_label = kwargs.get("x_label")
+        y_label = kwargs.get("y_label")
+
+        try:
+            # Validate inputs
+            if not y_values:
+                return json.dumps({"error": "No data provided for plotting"})
+
+            # Convert to floats if needed
+            try:
+                y_values = [float(v) if v is not None else None for v in y_values]
+                if x_values:
+                    x_values = [float(v) if v is not None else None for v in x_values]
+            except (ValueError, TypeError) as e:
+                return json.dumps({"error": f"Invalid data format: {str(e)}"})
+
+            # Create the plot
+            if plot_type == "histogram":
+                # For histogram, we only need y_values
+                histogram(
+                    y_values,
+                    title=title,
+                    bins=min(20, len(set(y_values))),  # Adaptive bin count
+                )
+                plot_info = {
+                    "type": "histogram",
+                    "data_points": len(y_values),
+                    "title": title or "Histogram",
+                }
+            elif plot_type in ["line", "scatter"]:
+                # For line/scatter plots
+                plot_kwargs = {
+                    "ys": y_values,
+                    "title": title,
+                    "lines": plot_type == "line",
+                }
+
+                if x_values:
+                    plot_kwargs["xs"] = x_values
+                if x_label:
+                    plot_kwargs["x_unit"] = x_label
+                if y_label:
+                    plot_kwargs["y_unit"] = y_label
+
+                plot(**plot_kwargs)
+
+                plot_info = {
+                    "type": plot_type,
+                    "data_points": len(y_values),
+                    "title": title or f"{plot_type.capitalize()} Plot",
+                    "has_x_values": x_values is not None,
+                }
+            else:
+                return json.dumps({"error": f"Unsupported plot type: {plot_type}"})
+
+            return json.dumps(
+                {"success": True, "plot_rendered": True, "plot_info": plot_info}
+            )
+
+        except Exception as e:
+            return json.dumps({"error": f"Error creating plot: {str(e)}"})

{sqlsaber-0.14.0.dist-info → sqlsaber-0.16.0.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.14.0
-Summary: SQLSaber - Agentic SQL assistant like Claude Code
+Version: 0.16.0
+Summary: SQLsaber - Open-source agentic SQL assistant
 License-File: LICENSE
 Requires-Python: >=3.12
 Requires-Dist: aiomysql>=0.2.0
 Requires-Dist: aiosqlite>=0.21.0
-Requires-Dist: anthropic>=0.54.0
 Requires-Dist: asyncpg>=0.30.0
 Requires-Dist: cyclopts>=3.22.1
 Requires-Dist: fastmcp>=2.9.0
@@ -14,27 +13,21 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: keyring>=25.6.0
 Requires-Dist: pandas>=2.0.0
 Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: pydantic-ai
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: uniplot>=0.21.2
 Description-Content-Type: text/markdown
 
-# SQLSaber
+# SQLsaber
 
-```
-███████  ██████  ██      ███████  █████  ██████  ███████ ██████
-██      ██    ██ ██      ██      ██   ██ ██   ██ ██      ██   ██
-███████ ██    ██ ██      ███████ ███████ ██████  █████   ██████
-     ██ ██ ▄▄ ██ ██           ██ ██   ██ ██   ██ ██      ██   ██
-███████  ██████  ███████ ███████ ██   ██ ██████  ███████ ██   ██
-            ▀▀
-```
+> SQLsaber is an open-source agentic SQL assistant. Think Claude Code but for SQL.
 
-> Use the agent Luke!
+![demo](./sqlsaber.gif)
 
-SQLSaber is an agentic SQL assistant. Think Claude Code but for SQL.
+Stop fighting your database.
 
-Ask your questions in natural language and it will gather the right context automatically and answer your query by writing SQL and analyzing the results.
+Ask your questions in natural language and `sqlsaber` will gather the right context automatically and answer your query by writing SQL and analyzing the results.
 
 ## Table of Contents
 
@@ -59,14 +52,13 @@ Ask your questions in natural language and it will gather the right context auto
 
 ## Features
 
-- Natural language to SQL conversion
 - 🔍 Automatic database schema introspection
 - 🛡️ Safe query execution (read-only by default)
 - 🧠 Memory management
 - 💬 Interactive REPL mode
-- 🎨 Beautiful formatted output with syntax highlighting
 - 🗄️ Support for PostgreSQL, SQLite, and MySQL
 - 🔌 MCP (Model Context Protocol) server support
+- 🎨 Beautiful formatted output
 
 ## Installation
 
@@ -165,34 +157,21 @@ saber -d mydb
 
 # Single query with specific database
 saber -d mydb "count all orders"
+
+# You can also pass a connection string
+saber -d "postgresql://user:password@localhost:5432/mydb" "count all orders"
 ```
 
 ## Examples
 
 ```bash
-# Show database schema
-saber "what tables are in my database?"
-
-# Count records
-saber "how many active users do we have?"
+# Start interactive mode
+saber
 
-# Complex queries with joins
+# Non-interactive mode
 saber "show me orders with customer details for this week"
 
-# Aggregations
-saber "what's the total revenue by product category?"
-
-# Date filtering
-saber "list users who haven't logged in for 30 days"
-
-# Data exploration
-saber "show me the distribution of customer ages"
-
-# Business analytics
 saber "which products had the highest sales growth last quarter?"
-
-# Start interactive mode
-saber
 ```
 
 ## MCP Server Integration
@@ -214,7 +193,7 @@ uvx --from sqlsaber saber-mcp
 Add SQLSaber as an MCP server in Claude Code:
 
 ```bash
-claude mcp add -- uvx --from sqlsaber saber-mcp
+claude mcp add sqlsaber -- uvx --from sqlsaber saber-mcp
 ```
 
 #### Other MCP Clients
@@ -234,7 +213,7 @@ The MCP server uses your existing SQLSaber database configurations, so make sure
 
 ## How It Works
 
-SQLSaber uses a multi-step process to gather the right context, provide it to the model, and execute SQL queries to get the right answers:
+SQLsaber uses a multi-step agentic process to gather the right context and execute SQL queries to answer your questions:
 
 ![](./sqlsaber.svg)
 
@@ -255,7 +234,9 @@ SQLSaber uses a multi-step process to gather the right context, provide it to th
 
 ## Contributing
 
-Contributions are welcome! Please feel free to open an issue to discuss your ideas or report bugs.
+If you like the project, starring the repo is a great way to show your support!
+
+Other contributions are welcome! Please feel free to open an issue to discuss your ideas or report bugs.
 
 ## License
 

sqlsaber-0.16.0.dist-info/RECORD

@@ -0,0 +1,51 @@
+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=2JX7UKW7tbqxPaK4aQLpXIwT3uszdBQHdSsOyML2U7I,6353
+sqlsaber/agents/mcp.py,sha256=GcJTx7YDYH6aaxIADEIxSgcWAdWakUx395JIzVnf17U,768
+sqlsaber/agents/pydantic_ai_agent.py,sha256=dGdsgyxCZvfK-v-MH8KimKOr-xb2aSfSWY8CMcOUCT8,6795
+sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
+sqlsaber/cli/auth.py,sha256=jTsRgbmlGPlASSuIKmdjjwfqtKvjfKd_cTYxX0-QqaQ,7400
+sqlsaber/cli/commands.py,sha256=caWyMqOyCJVM0gpC4M_7DMuI7fzsf4Kcm_BJxOQrkM0,6718
+sqlsaber/cli/completers.py,sha256=HsUPjaZweLSeYCWkAcgMl8FylQ1xjWBWYTEL_9F6xfU,6430
+sqlsaber/cli/database.py,sha256=atwg3l8acQ3YTDuhq7vNrBN6tpOv0syz6V62KTF-Bh8,12910
+sqlsaber/cli/display.py,sha256=HtXwPe3VPUh2EJpyvpJVWyisCanu9O7w-rkqq7Y4UaY,9791
+sqlsaber/cli/interactive.py,sha256=SNOV_MaqJt2NQr6H8GbbWzMyuGx2NLFEXetjKtFAefw,9635
+sqlsaber/cli/memory.py,sha256=OufHFJFwV0_GGn7LvKRTJikkWhV1IwNIUDOxFPHXOaQ,7794
+sqlsaber/cli/models.py,sha256=ZewtwGQwhd9b-yxBAPKePolvI1qQG-EkmeWAGMqtWNQ,8986
+sqlsaber/cli/streaming.py,sha256=3KXDu8_IJDkt-q6HoO7LYtLXjliNwWy_pOrgV8BQ6Bg,5453
+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=c6q3l4EvoBch1ckYHA70hf6L7fSOY-sItnLCpvJiPrA,11357
+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/conversation/__init__.py,sha256=xa-1gX6NsZpVGg_LDrsZAtDtsDo5FZc1SO8gwtm_IPk,302
+sqlsaber/conversation/manager.py,sha256=LDfmKGIMvTzsL7S0aXGWw6Ve54CHIeTGLU4qwes2NgU,7046
+sqlsaber/conversation/models.py,sha256=fq4wpIB2yxLCQtsXhdpDji4FpscG2ayrOBACrNvgF14,3510
+sqlsaber/conversation/storage.py,sha256=phpGEnZjXVFTmV5PalCKZpiO9VFHubMMfWA9OJCDbwc,11626
+sqlsaber/database/__init__.py,sha256=a_gtKRJnZVO8-fEZI7g3Z8YnGa6Nio-5Y50PgVp07ss,176
+sqlsaber/database/connection.py,sha256=sJtIIe0GVbo-1Py9-j66UxJoY1aKL9gqk68jkDL-Kvk,15123
+sqlsaber/database/resolver.py,sha256=RPXF5EoKzvQDDLmPGNHYd2uG_oNICH8qvUjBp6iXmNY,3348
+sqlsaber/database/schema.py,sha256=OC93dnZkijCoVNqb6itSpQ2XsiZ85PjVUW-VZDwrPrk,25989
+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/models/__init__.py,sha256=b3KVyLN7Y7p2rT1-TlIExpkO26bTG04-VCFwDmBO6i0,204
+sqlsaber/models/types.py,sha256=w-zk81V2dtveuteej36_o1fDK3So428j3P2rAejU62U,862
+sqlsaber/tools/__init__.py,sha256=a-JNOhHsC7WEVhTsQY_IHckaPOmswoM3Q85YOd2iC_E,652
+sqlsaber/tools/base.py,sha256=XLaHrAzZc4OUiOsKBvEfZCtWKDBd5WqgNAnmRufnOp4,2174
+sqlsaber/tools/enums.py,sha256=TnlvEOpkGtuzEzg_JBdSb_S38jg4INhtxw4qZ20kU_E,483
+sqlsaber/tools/instructions.py,sha256=nnItVvJBtN-FLB3-PSR6Y23ix6AiOB5hNX3r4TtYFKw,9869
+sqlsaber/tools/registry.py,sha256=decVRNf50JPNT4i-OHZIL2B8cmoOMDaE4y0Av6q6v0I,3619
+sqlsaber/tools/sql_tools.py,sha256=hM6tKqW5MDhFUt6MesoqhTUqIpq_5baIIDoN1MjDCXY,9647
+sqlsaber/tools/visualization_tools.py,sha256=059Pe3aOZvgpqT9487Ydv2PhY7T1pVmfALPTvfqPisI,4973
+sqlsaber-0.16.0.dist-info/METADATA,sha256=wa2OqUBvJu-KGPMsH0vhULYksY9sDcn-nRJihroMzA8,5966
+sqlsaber-0.16.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.16.0.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
+sqlsaber-0.16.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.16.0.dist-info/RECORD,,