sql2api 0.1.0__py3-none-any.whl

sql2api/store.py

@@ -0,0 +1,257 @@
+"""Persistence: the connection registry and the saved-query files (plain JSON on disk).
+
+Everything that touches those files goes through here so that access stays confined to the
+configured home folder and read-modify-write cycles are serialised.
+"""
+import json
+import os
+import re
+import threading
+import uuid
+from datetime import datetime
+
+from . import config
+from .errors import ApiError
+
+# Serialises read-modify-write cycles on the JSON files this app manages.
+lock = threading.RLock()
+
+_ENV_REF_RE = re.compile(r'\$\{(\w+)\}')
+_FILENAME_RE = re.compile(r'^[\w .\-]{1,100}$')
+
+
+def write_json_atomic(path, data):
+    tmp_path = f'{path}.{uuid.uuid4().hex}.tmp'
+    with open(tmp_path, 'w') as f:
+        json.dump(data, f, indent=4)
+    os.replace(tmp_path, path)
+
+
+def now():
+    return datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+
+# --------------------------------------------------------------------------------------
+# Connections
+# --------------------------------------------------------------------------------------
+
+def read_connections():
+    try:
+        with open(config.connections_file(), 'r') as f:
+            data = json.load(f)
+    except FileNotFoundError:
+        return {}
+    return data.get('connections', {})
+
+
+def _expand_env(value):
+    """Replace ${VAR} references in a connection value with the environment variable's content."""
+    if not isinstance(value, str):
+        return value
+
+    def replace(match):
+        name = match.group(1)
+        if name not in os.environ:
+            raise ApiError(f"Environment variable '{name}' referenced by the connection is not set", 500)
+        return os.environ[name]
+
+    return _ENV_REF_RE.sub(replace, value)
+
+
+def get_connection(connection_name):
+    """Return the usable (active, env-expanded) details of a named connection."""
+    if not isinstance(connection_name, str) or not connection_name:
+        raise ApiError('Connection name is missing')
+    details = read_connections().get(connection_name)
+    if not details:
+        raise ApiError(f"Connection '{connection_name}' not found", 404)
+    if not details.get('active', False):
+        raise ApiError(f"The connection '{connection_name}' is currently not active. "
+                       "To use it, it must be set to active.", 403)
+    if details.get('db') not in config.SUPPORTED_DB_TYPES:
+        raise ApiError('Unsupported database type')
+    return {key: _expand_env(value) for key, value in details.items()}
+
+
+def mask_passwords(connections):
+    """Hide stored passwords; ${VAR} references are not secrets and stay visible."""
+    def mask(conn):
+        password = conn.get('password')
+        if password and not _ENV_REF_RE.fullmatch(str(password)):
+            return {**conn, 'password': config.PASSWORD_MASK}
+        return conn
+
+    return {name: mask(conn) for name, conn in connections.items()}
+
+
+def update_connections(connections):
+    for name, details in connections.items():
+        if not isinstance(details, dict) or details.get('db') not in config.SUPPORTED_DB_TYPES:
+            raise ApiError(f"Connection '{name}' must be an object whose 'db' is one of: "
+                           f"{', '.join(config.SUPPORTED_DB_TYPES)}")
+    with lock:
+        existing = read_connections()
+        for name, details in connections.items():
+            # GET masks passwords, so a client echoing the mask back means "keep the current one".
+            if details.get('password') == config.PASSWORD_MASK and name in existing:
+                details = {**details, 'password': existing[name].get('password', '')}
+            existing[name] = details
+        config.home().mkdir(parents=True, exist_ok=True)
+        write_json_atomic(config.connections_file(), {'connections': existing})
+
+
+def delete_connection(name):
+    with lock:
+        existing = read_connections()
+        if name not in existing:
+            raise ApiError(f"Connection '{name}' not found", 404)
+        del existing[name]
+        write_json_atomic(config.connections_file(), {'connections': existing})
+
+
+# --------------------------------------------------------------------------------------
+# Saved queries (all access is confined to the saved_sql folder)
+# --------------------------------------------------------------------------------------
+
+def saved_path_for_name(filename):
+    """Path of the saved-query file for a client-supplied name (without extension)."""
+    if not isinstance(filename, str) or not _FILENAME_RE.match(filename) or filename.startswith('.'):
+        raise ApiError("Filename may only contain letters, digits, spaces, '.', '_' and '-'")
+    return os.path.join(config.saved_sql_dir(), f'{filename}.json')
+
+
+def resolve_saved_file(ref):
+    """Resolve a client-supplied file reference to an existing .json file inside the saved_sql folder.
+
+    Accepts a bare name ("cht" or "cht.json"), a path relative to the home folder
+    ("saved_sql/cht.json") or an absolute path - as long as it ends up in the saved_sql folder.
+    """
+    if not isinstance(ref, str) or not ref.strip():
+        raise ApiError('Filename is missing')
+    saved_dir = str(config.saved_sql_dir())
+    if os.path.isabs(ref):
+        candidate = ref
+    elif os.sep in ref or '/' in ref:
+        candidate = os.path.join(config.home(), ref)
+    else:
+        candidate = os.path.join(saved_dir, ref if ref.endswith('.json') else f'{ref}.json')
+    candidate = os.path.realpath(candidate)
+    if os.path.dirname(candidate) != os.path.realpath(saved_dir) or not candidate.endswith('.json'):
+        raise ApiError('Only .json files inside the saved_sql folder can be accessed', 403)
+    if not os.path.isfile(candidate):
+        raise ApiError('File not found', 404)
+    return candidate
+
+
+def load_versions(path):
+    try:
+        with open(path, 'r') as f:
+            content = json.load(f)
+    except json.JSONDecodeError:
+        raise ApiError('Saved query file is not valid JSON', 500) from None
+    if not isinstance(content, dict):
+        raise ApiError('Saved query file has an unexpected structure', 500)
+    return content
+
+
+def version_numbers(content):
+    return [int(v) for v in content if v.isdigit()]
+
+
+def select_version(content, version=None):
+    """Return (number, data) for the requested version, or the latest one when none is given."""
+    if version is None:
+        numbers = version_numbers(content)
+        if not numbers:
+            raise ApiError('No valid versions found in the file')
+        version = max(numbers)
+    data = content.get(str(version))
+    if not isinstance(data, dict):
+        raise ApiError(f'Version {version} not found', 404)
+    return int(version), data
+
+
+def save_version(filename, fields):
+    """Store ``fields`` as the next version of a saved query; returns (uuid, version number)."""
+    path = saved_path_for_name(filename)
+    query_uuid = str(uuid.uuid4())
+    timestamp = now()
+    with lock:
+        os.makedirs(config.saved_sql_dir(), exist_ok=True)
+        versions = load_versions(path) if os.path.exists(path) else {}
+        number = max(version_numbers(versions), default=0) + 1
+        versions[str(number)] = {
+            'uuid': query_uuid,
+            **fields,
+            'created_at': timestamp,
+            'last_modified_at': timestamp,
+            'status': 'active',
+            'version': number,
+            'execution_history': [],
+        }
+        write_json_atomic(path, versions)
+    return query_uuid, number
+
+
+def delete_saved(ref, version=None):
+    """Delete a saved query file, or a single version of it (the file goes with its last version)."""
+    path = resolve_saved_file(ref)
+    with lock:
+        if version is None:
+            os.remove(path)
+            return
+        content = load_versions(path)
+        if str(version) not in content:
+            raise ApiError(f'Version {version} not found', 404)
+        del content[str(version)]
+        if version_numbers(content):
+            write_json_atomic(path, content)
+        else:
+            os.remove(path)
+
+
+def record_execution(path, version, entry):
+    """Append to a saved version's execution_history (newest last, capped). Never raises."""
+    try:
+        with lock:
+            content = load_versions(path)
+            data = content.get(str(version))
+            if not isinstance(data, dict):
+                return
+            history = data.setdefault('execution_history', [])
+            history.append(entry)
+            del history[:-config.HISTORY_LIMIT]
+            write_json_atomic(path, content)
+    except (OSError, ApiError):
+        pass
+
+
+def list_saved():
+    """Return every saved query with its versions' metadata (SQL text is not included)."""
+    saved_dir = str(config.saved_sql_dir())
+    if not os.path.isdir(saved_dir):
+        raise ApiError('Folder not found', 404)
+    files = []
+    for filename in os.listdir(saved_dir):
+        file_path = os.path.join(saved_dir, filename)
+        if not (os.path.isfile(file_path) and filename.endswith('.json')):
+            continue
+        try:
+            content = load_versions(file_path)
+        except ApiError:
+            continue
+        versions = [{
+            'version': int(version),
+            'author': data.get('author'),
+            'description': data.get('description'),
+            'tags': data.get('tags', []),
+            'query_parameters': data.get('query_parameters', {}),
+            'connection_name': data.get('connection_name'),
+            'created_at': data.get('created_at'),
+            'last_modified_at': data.get('last_modified_at'),
+            'status': data.get('status'),
+            'execution_history': data.get('execution_history', []),
+        } for version, data in content.items() if version.isdigit() and isinstance(data, dict)]
+        versions.sort(key=lambda v: v['version'])
+        files.append({'filename': filename[:-5], 'versions': versions})
+    return files

sql2api-0.1.0.dist-info/METADATA

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: sql2api
+Version: 0.1.0
+Summary: Turn SQL into a REST API: run queries against MySQL, PostgreSQL, ClickHouse, SQLite or H2 over HTTP and get JSON, CSV, XML, YAML or XLSX back.
+Author-email: Anantha Raju C <arcswdev@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AnanthaRajuC/SQL2API
+Project-URL: Issues, https://github.com/AnanthaRajuC/SQL2API/issues
+Project-URL: Changelog, https://github.com/AnanthaRajuC/SQL2API/blob/main/CHANGELOG.md
+Keywords: sql,api,rest,flask,database,mysql,postgresql,clickhouse,sqlite,h2
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Flask
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Flask>=2.2
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: openpyxl>=3.1
+Provides-Extra: mysql
+Requires-Dist: mysql-connector-python>=8.0; extra == "mysql"
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9; extra == "postgres"
+Provides-Extra: clickhouse
+Requires-Dist: clickhouse-driver>=0.2; extra == "clickhouse"
+Provides-Extra: h2
+Requires-Dist: JayDeBeApi>=1.2; extra == "h2"
+Requires-Dist: JPype1>=1.4; extra == "h2"
+Provides-Extra: all
+Requires-Dist: sql2api[clickhouse,h2,mysql,postgres]; extra == "all"
+Provides-Extra: server
+Requires-Dist: gunicorn>=21; extra == "server"
+Provides-Extra: dev
+Requires-Dist: sql2api[all]; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Dynamic: license-file
+
+# SQL2API
+
+[![CI](https://github.com/AnanthaRajuC/SQL2API/actions/workflows/ci.yml/badge.svg)](https://github.com/AnanthaRajuC/SQL2API/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Python](https://img.shields.io/badge/python-3.9%2B-blue)
+
+**Turn SQL into a REST API.** SQL2API is a small Flask service that runs SQL against your databases and returns the
+results as JSON, NDJSON, CSV, TSV, XML, YAML or Excel. Save a query once and it becomes an endpoint with typed,
+injection-safe parameters, versioning and run history.
+
+~~~bash
+$ curl 'http://127.0.0.1:5000/q/actor_by_id?id=7'
+[{"actor_id": 7, "first_name": "GRACE", "last_name": "MOSTEL"}]
+
+$ curl 'http://127.0.0.1:5000/q/films_by_rating?rating=PG&max_length=60&format=csv&page_size=2'
+film_id,title,rating,length
+410,HEAVEN FREEDOM,PG,48
+443,HURRICANE AFFAIR,PG,49
+~~~
+
+| Database   | JSON | NDJSON | XML | YAML | CSV | TSV | XLSX |
+|------------|:----:|:------:|:---:|:----:|:---:|:---:|:----:|
+| MySQL      | ✅   | ✅     | ✅  | ✅   | ✅  | ✅  | ✅   |
+| PostgreSQL | ✅   | ✅     | ✅  | ✅   | ✅  | ✅  | ✅   |
+| ClickHouse | ✅   | ✅     | ✅  | ✅   | ✅  | ✅  | ✅   |
+| SQLite     | ✅   | ✅     | ✅  | ✅   | ✅  | ✅  | ✅   |
+| H2         | ✅   | ✅     | ✅  | ✅   | ✅  | ✅  | ✅   |
+
+## Features
+
+- **Ad-hoc queries** - `POST /execute_sql` with SQL and a connection name.
+- **Saved, versioned queries** - every save creates a new version; `GET /q/<name>?id=7` runs the latest one
+  (or `?version=1`). Each run is recorded in the query's execution history.
+- **Bound parameters** - write `WHERE id = :id` and the value is sent to the database separately from the SQL, so it
+  cannot inject anything. Declare types (`{"id": "int"}`) and query-string values are converted for you.
+- **Pagination** - `?page=2&page_size=50`, with `X-Has-More` telling you whether another page exists.
+- **Read-only by default** - only single `SELECT`/`WITH`/`SHOW`/`DESCRIBE`/`EXPLAIN` statements run, and sessions are
+  opened read-only where the database supports it.
+- **Secrets stay out of files** - `"password": "${PG_PASSWORD}"` in `db_connections.json` reads the environment.
+- **Self-documenting** - OpenAPI at `/openapi.json`, Swagger UI at `/docs`.
+
+## Install
+
+~~~bash
+pip install "sql2api[postgres]"         # pick the drivers you need: mysql, postgres, clickhouse, h2
+# or everything:                        pip install "sql2api[all]"
+~~~
+
+SQLite needs no extra driver. H2 also needs a Java runtime (the H2 JDBC jar is bundled).
+From a clone: `pip install -e ".[dev]"`. Or use Docker - see [below](#docker).
+
+## Quick start
+
+The repository ships two sample SQLite databases and a couple of saved queries:
+
+~~~bash
+cd examples
+cp db_connections.example.json db_connections.json
+sql2api serve                            # http://127.0.0.1:5000
+~~~
+
+~~~bash
+curl -X POST 'http://127.0.0.1:5000/execute_sql?page_size=3' -H 'Content-Type: application/json' \
+     -d '{"sql": "SELECT * FROM actor WHERE actor_id > :min", "params": {"min": 10}, "connection_name": "sakila-sqlite"}'
+~~~
+
+Open <http://127.0.0.1:5000/docs> for the interactive API reference.
+
+For your own databases, run `sql2api init` in an empty folder: it creates `db_connections.json` (inactive templates for
+every supported database) and `saved_sql/`. Edit the file, set `"active": true`, and start the server there.
+
+## Saving a query as an endpoint
+
+~~~bash
+curl -X PATCH http://127.0.0.1:5000/save_sql_to_file -H 'Content-Type: application/json' -d '{
+  "filename": "actor_by_id",
+  "sql_query": "SELECT * FROM actor WHERE actor_id = :id",
+  "query_parameters": {"id": "int"},
+  "connection_name": "sakila-sqlite",
+  "author": "me", "description": "Look up an actor"
+}'
+
+curl 'http://127.0.0.1:5000/q/actor_by_id?id=7&format=yaml'
+~~~
+
+Saving again under the same name adds version 2; `DELETE /saved_sql/actor_by_id?version=1` removes one version.
+
+## Configuration
+
+Everything is configured through environment variables (all optional):
+
+| Variable | Default | Effect |
+|----------|---------|--------|
+| `SQL2API_HOME` | current directory | Folder holding `db_connections.json` and `saved_sql/`. |
+| `SQL2API_ALLOW_WRITES` | off | Allow `INSERT`/`UPDATE`/DDL. Otherwise only single read-only statements are accepted. |
+| `SQL2API_API_KEY` | unset | When set, every request (except `/health` and `/docs`) needs a matching `X-API-Key` header. |
+| `SQL2API_MAX_PAGE_SIZE` | `1000` | Upper limit for `page_size`. |
+| `SQL2API_HOST` / `SQL2API_PORT` | `127.0.0.1` / `5000` | Bind address for `sql2api serve`. |
+| `SQL2API_DEBUG` | off | Flask debug mode. Never enable on a reachable host. |
+| `SQL2API_H2_JAR` | bundled | Path to a different H2 JDBC jar. |
+
+## Security
+
+SQL2API runs whatever SQL it is given against your databases, so it ships locked down and expects you to finish the job:
+
+- Set `SQL2API_API_KEY` and serve over TLS (put it behind a reverse proxy).
+- Connect with a database account that only has the privileges the API needs - the read-only guard is
+  defence in depth, not a replacement for grants. (H2's driver cannot enforce read-only, so H2 relies on the guard.)
+- Use bound `:name` parameters. The older `{name}` placeholders paste text into the SQL and are therefore restricted
+  to numbers and plain text.
+- Saved-query files are only read from `saved_sql/`; passwords are never returned by the API.
+
+See [SECURITY.md](SECURITY.md) to report a vulnerability.
+
+## Docker
+
+~~~bash
+docker build -t sql2api .                          # add --build-arg WITH_H2=true for H2 support
+docker run -p 5000:5000 -v "$PWD/data:/data" -e SQL2API_API_KEY=change-me sql2api
+~~~
+
+The container keeps `db_connections.json` and `saved_sql/` in `/data`. It runs gunicorn with a single worker
+(the files are protected by an in-process lock).
+
+## API overview
+
+| Endpoint | Method | Purpose |
+|----------|--------|---------|
+| `/execute_sql` | POST | Run ad-hoc SQL (`sql`, `connection_name`, optional `params`). |
+| `/q/<name>` | GET, POST | Run a saved query; query-string or body values become parameters. |
+| `/save_sql_to_file` | PATCH | Save a query (creates the next version). |
+| `/list_files` | GET | List saved queries and their versions (`sort_by`, `sort_order`). |
+| `/saved_sql/<name>` | DELETE | Delete a saved query or one `?version=`. |
+| `/view_file_content` | GET | Raw content of a saved query file. |
+| `/execute_sql_from_file`, `/execute_sql_with_parameters_from_file` | POST | Run a saved query by `filepath` (same as `/q/<name>`). |
+| `/connections` | GET, PATCH | List (passwords masked) / add / update connections. |
+| `/connections/<name>` | DELETE | Remove a connection. |
+| `/health`, `/docs`, `/openapi.json` | GET | Liveness, Swagger UI, OpenAPI spec. |
+
+Full details are in [documentation/API.md](documentation/API.md).
+
+## Development
+
+~~~bash
+pip install -e ".[dev]"
+ruff check .
+python -m unittest discover -s tests -t .
+~~~
+
+The integration tests in `tests/test_integration.py` run against real MySQL, PostgreSQL, ClickHouse and H2 servers when
+the matching `SQL2API_IT_*` variables are set, and are skipped otherwise; CI runs them against service containers.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the pull request process, and [CHANGELOG.md](CHANGELOG.md) for what changed.
+
+## Third-party components
+
+The wheel bundles the [H2 Database](https://h2database.com) JDBC driver (MPL 2.0 / EPL 1.0). The sample SQLite
+databases in `examples/` derive from the Sakila and Chinook sample datasets.
+
+## License
+
+[MIT](LICENSE) © Anantha Raju C
+
+## Contact
+
+Anantha Raju C - [@anantharajuc](https://twitter.com/anantharajuc) - arcswdev@gmail.com
+
+Project link: <https://github.com/AnanthaRajuC/SQL2API>

sql2api-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+sql2api/__init__.py,sha256=FeKzfwtM7UszmZ7HBQ8AQi_WNHabfDeAIpWARwhqfys,185
+sql2api/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+sql2api/app.py,sha256=VwoiN9TC2a8wPbCyf3IFMuWsnjteH5scrItLKIgbOoI,11447
+sql2api/cli.py,sha256=1L3RYiCgnh1w_speXB4RPqxNWs5kR7kT68X9L-aqDLk,2712
+sql2api/config.py,sha256=goaJF810BKzyeENR-6lc1l6k1OdSaF4-3CJkpMWv4gU,2222
+sql2api/engine.py,sha256=b4uS0FZAWuUipr_CpAWjyVYPyzTtiDD2HDnfvI1PNP0,1551
+sql2api/errors.py,sha256=nJddO1gAjxQZH7-IXf3Bt8ruxv3EhVw6t6viFKfluG4,264
+sql2api/formats.py,sha256=SbLDZ-yQIt7pcWXYi8WNYEmG6JNqoeeGeRwIg5XHmos,4817
+sql2api/openapi.py,sha256=evoO6KsPN0UjvdxYR0dwHTMygAI-7FIPxhURh7i4rXY,8597
+sql2api/runners.py,sha256=tiP4-zNaD-bSdTycr1OBiHx00A-KESpLXXudhAhwBFw,5218
+sql2api/sqltools.py,sha256=HPNC2hCSkBqiJ8O-WYWj7gwILnNOtyVD5A_58SG3lik,6657
+sql2api/store.py,sha256=OHLE1PU7ZrqQcPJec4jJbqNeFBDSt7TOUO8NfH7QLJg,9890
+sql2api/lib/h2-2.2.224.jar,sha256=udjxk1itqCpPbrWxdMbP4yCjdbWpy1pP5FbWI-blVJc,2614933
+sql2api-0.1.0.dist-info/licenses/LICENSE,sha256=ufgSbLEx8zM6J0kFgDoK-6NNb0gqrsFfCb-CnNbZGg0,1071
+sql2api-0.1.0.dist-info/METADATA,sha256=xrC-ppNP7rufNkYTdi_eFDmkieHx_jEjirZOFsf8F38,9461
+sql2api-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sql2api-0.1.0.dist-info/entry_points.txt,sha256=63gZjCA84qTkErE2iiuTiGS7GtdamvOqi2elEXwy_zE,45
+sql2api-0.1.0.dist-info/top_level.txt,sha256=dicWZ6j0AE1xBDKr0-qh2CkuP7Yc1CWQf_T6r8LS6ms,8
+sql2api-0.1.0.dist-info/RECORD,,

sql2api-0.1.0.dist-info/WHEEL

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

sql2api-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sql2api = sql2api.cli:main

sql2api-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Anantha Raju C
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sql2api-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sql2api