sqlpiston 0.1.0__py3-none-any.whl

sqlpiston/core/engine/base.py

@@ -0,0 +1,99 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any, List, Optional, Tuple
+
+from sqlpiston.builder.nodes import ExprValue
+from sqlpiston._types import SQLValue
+from sqlpiston.compiler.base import Dialect
+
+
+class DBType(Enum):
+    MySQL = 1
+    SQLite = 2
+
+
+class Cursor(ABC):
+    """Query result cursor. Wraps DB-API cursor."""
+
+    @abstractmethod
+    def fetchall(self) -> List[Tuple[SQLValue, ...]]:
+        ...
+
+    @abstractmethod
+    def fetchone(self) -> Optional[Tuple[SQLValue, ...]]:
+        ...
+
+    @property
+    @abstractmethod
+    def rowcount(self) -> int:
+        ...
+
+    @property
+    @abstractmethod
+    def description(self) -> List[Tuple[str, int, Any, Any, Any, Any, Any]]:
+        ...
+
+
+class Connection(ABC):
+    """A single database connection."""
+
+    @abstractmethod
+    def execute(self, sql: str, params: Tuple[ExprValue, ...]) -> Cursor:
+        ...
+
+    @abstractmethod
+    def begin(self) -> None:
+        ...
+
+    @abstractmethod
+    def commit(self) -> None:
+        ...
+
+    @abstractmethod
+    def rollback(self) -> None:
+        ...
+
+    @abstractmethod
+    def close(self) -> None:
+        ...
+
+    def __enter__(self) -> 'Connection':  # pragma: no cover — abstract class, covered via subclasses
+        return self
+
+    def __exit__(self, *args: Any) -> None:  # pragma: no cover — abstract class, covered via subclasses
+        self.close()
+
+
+class Engine(ABC):
+    """Abstract database engine."""
+
+    @property
+    @abstractmethod
+    def dialect(self) -> Dialect:
+        ...
+
+    @abstractmethod
+    def connect(self) -> Connection:
+        ...
+
+    @abstractmethod
+    def close(self) -> None:
+        ...
+
+    def __enter__(self) -> 'Engine':  # pragma: no cover — abstract class, covered via subclasses
+        return self
+
+    def __exit__(self, *args: Any) -> None:  # pragma: no cover — abstract class, covered via subclasses
+        self.close()
+
+
+def DBEngine(db_type: DBType) -> Engine:
+    """Factory: returns typed engine by DBType."""
+    if db_type == DBType.MySQL:
+        from sqlpiston.core.engine.mysql import MySQLEngine
+        return MySQLEngine()
+    elif db_type == DBType.SQLite:
+        from sqlpiston.core.engine.sqlite import SQLiteEngine
+        return SQLiteEngine()
+    else:
+        raise ValueError(f"Unsupported DB type: {db_type}")

sqlpiston/core/engine/mysql.py

@@ -0,0 +1,80 @@
+from typing import Any, Dict, List, Optional, Tuple, cast
+
+from sqlpiston.builder.nodes import ExprValue
+from sqlpiston._types import SQLValue
+from sqlpiston.compiler.mysql import MySQLDialect
+from sqlpiston.core.engine.base import Connection, Cursor, Engine
+
+
+class MySQLCursor(Cursor):  # pragma: no cover — requires mysql.connector (optional dependency)
+    def __init__(self, raw_cursor: Any) -> None:
+        self._cursor = raw_cursor
+
+    def fetchall(self) -> List[Tuple[SQLValue, ...]]:
+        return [tuple(row) for row in self._cursor.fetchall()]
+
+    def fetchone(self) -> Optional[Tuple[SQLValue, ...]]:
+        row = self._cursor.fetchone()
+        return tuple(row) if row else None
+
+    @property
+    def rowcount(self) -> int:
+        return int(self._cursor.rowcount)
+
+    @property
+    def description(self) -> List[Tuple[str, int, Any, Any, Any, Any, Any]]:  # pragma: no cover — requires mysql.connector
+        desc = self._cursor.description
+        if desc is None:
+            return []
+        return cast(List[Tuple[str, int, Any, Any, Any, Any, Any]], desc)
+
+
+class MySQLConnection(Connection):  # pragma: no cover — requires mysql.connector (optional dependency)
+    def __init__(self, raw_conn: Any) -> None:
+        self._conn = raw_conn
+
+    def execute(self, sql: str, params: Tuple[ExprValue, ...]) -> MySQLCursor:
+        cursor = self._conn.cursor()
+        cursor.execute(sql, params)
+        return MySQLCursor(cursor)
+
+    def begin(self) -> None:
+        self._conn.begin()
+
+    def commit(self) -> None:
+        self._conn.commit()
+
+    def rollback(self) -> None:
+        self._conn.rollback()
+
+    def close(self) -> None:
+        self._conn.close()
+
+
+class MySQLEngine(Engine):
+    def __init__(self) -> None:
+        self._config: Optional[Dict[str, Any]] = None
+        self._conn: Any = None
+
+    def init_engine(self, host: str, port: int, user: str, password: str, database: str) -> None:
+        self._config = {
+            'host': host, 'port': port,
+            'user': user, 'password': password,
+            'database': database,
+        }
+
+    @property
+    def dialect(self) -> MySQLDialect:
+        return MySQLDialect()
+
+    def connect(self) -> MySQLConnection:  # pragma: no cover — requires mysql.connector (optional dependency)
+        if self._config is None:
+            raise RuntimeError("Call init_engine() before connect()")
+        import mysql.connector  # type: ignore[import-not-found]
+        self._conn = mysql.connector.connect(**self._config)
+        return MySQLConnection(self._conn)
+
+    def close(self) -> None:  # pragma: no cover — requires mysql.connector
+        if self._conn:
+            self._conn.close()
+            self._conn = None

sqlpiston/core/engine/sqlite.py

@@ -0,0 +1,76 @@
+import sqlite3
+from typing import Any, List, Optional, Tuple, cast
+
+from sqlpiston.builder.nodes import ExprValue
+from sqlpiston._types import SQLValue
+from sqlpiston.compiler.sqlite import SQLiteDialect
+from sqlpiston.core.engine.base import Connection, Cursor, Engine
+
+
+class SQLiteCursor(Cursor):
+    def __init__(self, raw_cursor: sqlite3.Cursor) -> None:
+        self._cursor = raw_cursor
+
+    def fetchall(self) -> List[Tuple[SQLValue, ...]]:
+        return [tuple(row) for row in self._cursor.fetchall()]
+
+    def fetchone(self) -> Optional[Tuple[SQLValue, ...]]:
+        row = self._cursor.fetchone()
+        return tuple(row) if row else None
+
+    @property
+    def rowcount(self) -> int:
+        return self._cursor.rowcount
+
+    @property
+    def description(self) -> List[Tuple[str, int, Any, Any, Any, Any, Any]]:
+        desc = self._cursor.description
+        if desc is None:
+            return []
+        return cast(List[Tuple[str, int, Any, Any, Any, Any, Any]], [tuple(d) for d in desc])
+
+
+class SQLiteConnection(Connection):
+    def __init__(self, raw_conn: sqlite3.Connection) -> None:
+        self._conn = raw_conn
+
+    def execute(self, sql: str, params: Tuple[ExprValue, ...]) -> SQLiteCursor:
+        cursor = self._conn.cursor()
+        cursor.execute(sql, params)
+        return SQLiteCursor(cursor)
+
+    def begin(self) -> None:
+        self._conn.execute("BEGIN")
+
+    def commit(self) -> None:
+        self._conn.commit()
+
+    def rollback(self) -> None:
+        self._conn.rollback()
+
+    def close(self) -> None:
+        self._conn.close()
+
+
+class SQLiteEngine(Engine):
+    def __init__(self) -> None:
+        self._file_path: Optional[str] = None
+        self._conn: Optional[sqlite3.Connection] = None
+
+    def init_engine(self, file_path: str) -> None:
+        self._file_path = file_path
+
+    @property
+    def dialect(self) -> SQLiteDialect:
+        return SQLiteDialect()
+
+    def connect(self) -> SQLiteConnection:
+        if self._file_path is None:
+            raise RuntimeError("Call init_engine() before connect()")
+        self._conn = sqlite3.connect(self._file_path)
+        return SQLiteConnection(self._conn)
+
+    def close(self) -> None:
+        if self._conn:
+            self._conn.close()
+            self._conn = None

sqlpiston/core/pool.py

@@ -0,0 +1,49 @@
+import threading
+from typing import Any, List
+
+from sqlpiston.core.engine.base import Connection, Engine
+
+
+class ConnectionPool:
+    """Thread-safe connection pool."""
+
+    def __init__(self, engine: Engine, min_size: int = 1, max_size: int = 10) -> None:
+        self._engine = engine
+        self._min_size = min_size
+        self._max_size = max_size
+        self._lock = threading.Lock()
+        self._available: List[Connection] = []
+        self._in_use: int = 0
+
+        for _ in range(min_size):
+            self._available.append(engine.connect())
+
+    def acquire(self) -> Connection:
+        with self._lock:
+            if self._available:
+                conn = self._available.pop()
+                self._in_use += 1
+                return conn
+            if self._in_use >= self._max_size:
+                raise RuntimeError("Connection pool exhausted")
+            conn = self._engine.connect()
+            self._in_use += 1
+            return conn
+
+    def release(self, conn: Connection) -> None:
+        with self._lock:
+            self._in_use -= 1
+            self._available.append(conn)
+
+    def close(self) -> None:
+        with self._lock:
+            for conn in self._available:
+                conn.close()
+            self._available.clear()
+            self._in_use = 0
+
+    def __enter__(self) -> 'ConnectionPool':
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

sqlpiston/core/session.py

@@ -0,0 +1,61 @@
+from typing import Any, Optional
+
+from sqlpiston.builder.nodes import ASTNode
+from sqlpiston.core.engine.base import Connection, Engine
+from sqlpiston.core.pool import ConnectionPool
+from sqlpiston.orm.mapper import ResultSet
+
+
+class Session:
+    """Entry point for users. Binds engine, compiles AST, executes SQL.
+
+    Usage::
+
+        s = Session(engine)
+        result = s.execute(
+            Select().select('id', 'name').from_table('users').where(Field('age') >= 18)
+        )
+        s.commit()
+        s.close()
+    """
+
+    def __init__(self, engine: Engine, pool: Optional[ConnectionPool] = None) -> None:
+        self._engine = engine
+        self._pool = pool if pool is not None else ConnectionPool(engine)
+        self._current_conn: Optional[Connection] = None
+
+    def _get_conn(self) -> Connection:
+        if self._current_conn is None:
+            self._current_conn = self._pool.acquire()
+        return self._current_conn
+
+    def execute(self, stmt: ASTNode) -> ResultSet:
+        conn = self._get_conn()
+        sql, params = stmt.compile(self._engine.dialect)
+        cursor = conn.execute(sql, params)
+        column_names = [desc[0] for desc in cursor.description] if cursor.description else []
+        return ResultSet(cursor, column_names)
+
+    def begin(self) -> None:
+        conn = self._get_conn()
+        conn.begin()
+
+    def commit(self) -> None:
+        if self._current_conn:
+            self._current_conn.commit()
+
+    def rollback(self) -> None:
+        if self._current_conn:
+            self._current_conn.rollback()
+
+    def close(self) -> None:
+        if self._current_conn:
+            self._pool.release(self._current_conn)
+            self._current_conn = None
+        self._pool.close()
+
+    def __enter__(self) -> 'Session':
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()

sqlpiston/orm/mapper.py

@@ -0,0 +1,68 @@
+from typing import (
+    Any, Dict, Iterator, List, Optional, Type, TypeVar,
+)
+
+from sqlpiston._types import SQLValue
+from sqlpiston.core.engine.base import Cursor
+
+T = TypeVar('T')
+
+
+class ResultSet:
+    """Iterable set of mapped results from a query."""
+
+    def __init__(self, cursor: Cursor, column_names: List[str]) -> None:
+        self._cursor = cursor
+        self._column_names = column_names
+
+    def all(self) -> List[Dict[str, SQLValue]]:
+        rows = self._cursor.fetchall()
+        return [dict(zip(self._column_names, row)) for row in rows]
+
+    def one(self) -> Dict[str, SQLValue]:
+        rows = self.all()
+        if len(rows) == 0:
+            raise ValueError("Expected exactly one row, got none")
+        if len(rows) > 1:
+            raise ValueError(f"Expected exactly one row, got {len(rows)}")
+        return rows[0]
+
+    def one_or_none(self) -> Optional[Dict[str, SQLValue]]:
+        rows = self.all()
+        if len(rows) == 0:
+            return None
+        if len(rows) > 1:
+            raise ValueError(f"Expected at most one row, got {len(rows)}")
+        return rows[0]
+
+    def first(self) -> Optional[Dict[str, SQLValue]]:
+        row = self._cursor.fetchone()
+        if row is None:
+            return None
+        return dict(zip(self._column_names, row))
+
+    def scalar(self) -> Any:
+        row = self._cursor.fetchone()
+        if row is None:
+            raise ValueError("Expected at least one row for scalar(), got none")
+        return row[0]
+
+    def map(self, target: Type[T]) -> List[T]:
+        rows = self.all()
+        results: List[T] = []
+        for row in rows:
+            obj = target(**row)
+            results.append(obj)
+        return results
+
+    def map_one(self, target: Type[T]) -> T:
+        row = self.one()
+        return target(**row)
+
+    def __iter__(self) -> Iterator[Dict[str, SQLValue]]:
+        all_rows = self.all()
+        return iter(all_rows)
+
+    @property
+    def rowcount(self) -> int:
+        return self._cursor.rowcount

sqlpiston-0.1.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: sqlpiston
+Version: 0.1.0
+Summary: A low-level SQL library that builds parameterized SQL queries through Python operator overloading
+Author: MuliMuri
+License: MIT
+Keywords: sql,query-builder,orm,mysql,sqlite
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: coverage>=7; extra == "dev"
+Requires-Dist: flake8>=7; extra == "dev"
+Requires-Dist: mypy>=1; extra == "dev"
+Dynamic: license-file
+
+# SQLPiston
+
+[![test](https://github.com/MuliMuri/sqlpiston/actions/workflows/test.yml/badge.svg)](https://github.com/MuliMuri/sqlpiston/actions/workflows/test.yml)
+[![lint](https://github.com/MuliMuri/sqlpiston/actions/workflows/lint.yml/badge.svg)](https://github.com/MuliMuri/sqlpiston/actions/workflows/lint.yml)
+[![coverage](https://codecov.io/gh/MuliMuri/sqlpiston/branch/main/graph/badge.svg)](https://codecov.io/gh/MuliMuri/sqlpiston)
+[![pypi](https://img.shields.io/pypi/v/sqlpiston.svg)](https://pypi.org/project/sqlpiston/)
+[![python](https://img.shields.io/pypi/pyversions/sqlpiston)](https://pypi.org/project/sqlpiston/)
+[![license](https://img.shields.io/github/license/MuliMuri/sqlpiston)](https://github.com/MuliMuri/sqlpiston/blob/main/LICENSE)
+
+*Write once, query everywhere — build SQL with Python operators.*
+
+[中文版](README_ZH.md)
+
+SQLPiston is a low-level SQL library that builds parameterized SQL queries
+through Python operator overloading. AST nodes carry zero SQL knowledge;
+dialect-specific compilers translate the same AST into the right SQL for each
+database.
+
+## Install
+
+```bash
+git clone https://github.com/MuliMuri/sqlpiston.git
+cd sqlpiston
+pip install -e .
+```
+
+Python 3.9+ on Linux / macOS / Windows.
+
+## Basic Usage
+
+```python
+from sqlpiston import Select, Field, Insert
+from sqlpiston import DBEngine, DBType, Session
+from dataclasses import dataclass
+
+eng = DBEngine(DBType.SQLite)
+eng.init_engine(":memory:")
+session = Session(eng)
+
+stmt = (
+    Select()
+    .select("id", "name", "age")
+    .from_table("users")
+    .where((Field("age") >= 18) & (Field("status") == "active"))
+    .order_by("id", "ASC")
+    .limit(10)
+)
+result = session.execute(stmt)
+
+@dataclass
+class User:
+    id: int
+    name: str
+    age: int
+
+users = result.map(User)
+
+session.execute(
+    Insert().into("users").values({"name": "Alice", "age": 25})
+)
+
+session.commit()
+session.close()
+```
+
+<details>
+<summary>More examples: JOIN, subquery, CTE, UPSERT, DDL</summary>
+
+**JOIN**
+
+```python
+Select() \
+    .select("users.name", "orders.total") \
+    .from_table("users") \
+    .join("orders",
+          Field("user_id", "orders") == Field("id", "users")) \
+    .where(Field("total", "orders") > 100)
+```
+
+**Subquery (IN / EXISTS / Scalar)**
+
+```python
+# IN subquery
+admin_ids = Select().select("id").from_table("admins")
+stmt = Select().select("name").from_table("users") \
+    .where(Field("id").is_in(admin_ids))
+
+# EXISTS
+sub = Select().select("1").from_table("orders") \
+    .where(Field("user_id", "orders") == Field("id", "users"))
+stmt = Select().select("name").from_table("users").where(sub.exists())
+
+# Scalar
+avg = Select().select(SQLFunction("avg", "salary")).from_table("employees")
+stmt = Select().select("name").from_table("staff").where(Field("salary") > avg)
+```
+
+**CTE**
+
+```python
+cte = Select().select("*").from_table("sales") \
+    .where(Field("amount") > 100).cte("big_sales")
+stmt = Select().with_(cte).select("*").from_table("big_sales")
+```
+
+**UPSERT — same AST, different SQL per dialect**
+
+```python
+Upsert() \
+    .into("users") \
+    .values({"id": 1, "name": "X"}) \
+    .on_conflict("id") \
+    .do_update({"name": "X"})
+```
+
+| Dialect | Generated SQL |
+|---------|--------------|
+| MySQL   | `INSERT INTO ... ON DUPLICATE KEY UPDATE` |
+| SQLite  | `INSERT INTO ... ON CONFLICT DO UPDATE`   |
+
+**DDL**
+
+```python
+CreateTable().table("users").if_not_exists() \
+    .column("id", "INTEGER", primary_key=True, nullable=False) \
+    .column("name", "VARCHAR(255)")
+
+AlterTable().table("users").add_column("age", "INTEGER", default=0)
+
+DropTable().table("users").if_exists()
+```
+
+</details>
+
+## Highlights
+
+- **Operator overloading** — `Field("age") >= 18` builds AST, not a boolean
+- **Dialect-aware** — same AST compiles to MySQL (%s, backticks) or SQLite (?, double-quotes)
+- **Full standard SQL** — SELECT, INSERT, UPDATE, DELETE, UPSERT, CTE, UNION, subqueries, DDL
+- **Parameterized by design** — values never interpolated into SQL strings
+- **Weak ORM** — result-to-dataclass mapping, no identity map or change tracking
+
+## Documentation
+
+```bash
+cd docs
+pip install -r requirements.txt
+sphinx-build -b html source build/html
+```
+
+## License
+
+MIT

sqlpiston-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+sqlpiston/__init__.py,sha256=3ghxUHksL7Hf7K7z32-qK-X6hK6GmjLo5uEhVetOMEg,1054
+sqlpiston/_types.py,sha256=khQZ0rFi-wAxXF829o6Pj_GQEOfWqZt0uLTirIA0amA,125
+sqlpiston/builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlpiston/builder/ddl.py,sha256=LwzUlJLhh163ndZoJ7yPSW2Wz8gSzErJ-jsqXnV7_QI,6414
+sqlpiston/builder/dml.py,sha256=pkU5pINsQown4UY04I44mICPvgLxXUF4NRlZGiWu0Eo,3540
+sqlpiston/builder/nodes.py,sha256=XP30lmbUlHWnPT0_qvXMuAkUkN2SnuxDEnf4oIAARDA,8072
+sqlpiston/builder/selectable.py,sha256=B7c0hogEiFyyu3SRzdm85Ok4xU3fhy7VfMZwgKlQ638,5010
+sqlpiston/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlpiston/compiler/base.py,sha256=iSVVLK8NEjnxEhE0vjI_iRdpOBjFv5nIk1kAVqerAAg,24502
+sqlpiston/compiler/mysql.py,sha256=cbixJVUae699ht9Hx7zm5xqLcvSvhNPiRiPH9MkBJRI,2007
+sqlpiston/compiler/sqlite.py,sha256=ccRxvrnaIXzwz6xt1jjdstbQfUaAuQN-BJKxj5UrlMk,2134
+sqlpiston/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlpiston/core/pool.py,sha256=g69X70znqPgKjk_XNQm8w6I61KyV8IDVrQtPXrW3aHA,1434
+sqlpiston/core/session.py,sha256=1YMpdRE-kdaYkfgMTy-G2ZqGJMlmgP_feyyv96UBbHk,1861
+sqlpiston/core/engine/__init__.py,sha256=BTeVrKTDJuE_EENZKLv-UEkIo4d2MynUBA9xwkTNzvk,90
+sqlpiston/core/engine/base.py,sha256=Vc72j9B4dhwChnAoCN4K3ukNXb2E_ofUuafNIqCALFo,2347
+sqlpiston/core/engine/mysql.py,sha256=Ofb_Lo_0bNhun3jD27lUnXwSL9V-I5gkpRXHJgM861c,2734
+sqlpiston/core/engine/sqlite.py,sha256=s_QKIp2V7sBF4myvuNMrYlgUg-3jwyur2IFyDVD46A4,2273
+sqlpiston/orm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlpiston/orm/mapper.py,sha256=VzL9Hj-7jIS6eNKWhJvZ4RYSB7CjSnl8wsCZvU2xnBk,2010
+sqlpiston-0.1.0.dist-info/licenses/LICENSE,sha256=FKq1ES92GFfgEWVFaOrUwjYp5Vw1Ax7erfJD-hf8-T0,1065
+sqlpiston-0.1.0.dist-info/METADATA,sha256=hYCIoJfNuP0CCOMcxW2H6dj8YSrgyiRHMh6WPXt_S1w,5206
+sqlpiston-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sqlpiston-0.1.0.dist-info/top_level.txt,sha256=FrpiXMbeu-XF58dz1QZcE1FRBGK-GY2oA_m-E0uEtBw,10
+sqlpiston-0.1.0.dist-info/RECORD,,

sqlpiston-0.1.0.dist-info/WHEEL

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

sqlpiston-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MuliMuri
+
+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.

sqlpiston-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlpiston