sqlengine-lite 2.2.1__py3-none-any.whl → 2.2.2__py3-none-any.whl

sqlengine/_internal/connection_manager.py

@@ -20,8 +20,7 @@ class ConnectionManager:
     
     Args:
 
-        database (str): database filename to connect to. If `":memory:"` is passed, then database will be set in memory and you will have to
-            create table manually with `create_table()` method inside `transaction()` block.
+        database (str): database filename to connect to. If `":memory:"` is passed, then database will be set in memory.
         **connection_params: Params to create connection with. Reference: https://docs.python.org/3/library/sqlite3.html#sqlite3.connect
     """
 
@@ -139,7 +138,7 @@ class ConnectionManager:
         Args:
             query (str): SQL query
             *args (tuple[SqlValue, ...]): Arguments to the execution
-            size (str): Number of rows to return
+            size (int): Number of rows to return
 
         Returns:
             rows (list[SqlRow]): list of `size` rows
@@ -197,10 +196,14 @@ class ConnectionManager:
         if self._is_managed_transaction:
             raise TransactionError("Can't manually close managed transaction")
         
-        self._trans_cursor.close()
-        self._trans.close()
-        del(self._trans_cursor)
-        del(self._trans)
+        try:
+            self._trans_cursor.close()
+            self._trans.close()
+        except sqlite3.ProgrammingError as e:
+            raise TransactionError("Can't close connection properly") from e
+        finally:
+            del(self._trans_cursor)
+            del(self._trans)
 
 
     def commit(self) -> None:

sqlengine/_internal/statements.py

@@ -32,39 +32,46 @@ class Where[T : "Statement"]:
 
     
     def op(self, column : str, value : SqlValue, operator : str) -> Self:
+        """ Adds operator to the where clause """
         self._clause.append(f"{column} {operator} ?")
         self._args.append(value)
         return self
 
     
     def join(self, lop : str = "AND") -> Self:
-        """ Joins previous expression via logical operator `lop` """
+        """ Join previous expression via logical operator `lop` """
         joined = f" {lop} ".join(self._clause)
         self._clause = [f"({joined})"]
         return self
 
     
     def eq(self, column : str, value : SqlValue) -> Self:
+        """ Add `column = value` to the where clause """
         return self.op(column, value, "=")
 
     
     def neq(self, column : str, value : SqlValue) -> Self:
+        """ Add `column != value` to the where clause """
         return self.op(column, value, "!=")
     
     
     def gt(self, column : str, value : SqlValue) -> Self:
+        """ Add `column > value` to the where clause """
         return self.op(column, value, ">")
     
     
     def gte(self, column : str, value : SqlValue) -> Self:
+        """ Add `column >= value` to the where clause """
         return self.op(column, value, ">=")
     
     
     def lt(self, column : str, value : SqlValue) -> Self:
+        """ Add `column < value` to the where clause """
         return self.op(column, value, "<")
     
     
     def lte(self, column : str, value : SqlValue) -> Self:
+        """ Add `column <= value` to the where clause """
         return self.op(column, value, "<=")
     
     
@@ -77,12 +84,13 @@ class Where[T : "Statement"]:
     
     
     def is_null(self, column : str) -> Self:
+        """ Add `column IS NULL` to the where clause """
         self._clause.append(f"{column} IS NULL")
         return self
     
     
     def inverted(self) -> Self:
-        """ Invert last where clause with NOT """
+        """ Invert previous where clauses with `NOT` """
         self._clause[-1] = f"NOT ({self._clause[-1]})"
         return self
     
@@ -128,14 +136,16 @@ class Where[T : "Statement"]:
         return self._statement.__repr__()
 
     
+    def __iter__(self):
+        if not isinstance(self._statement, Select):
+            raise SqlEngineError("Can iterate only over `Select` statements")
+        return iter(self._statement)
+    
+
     def _repr_html_(self) -> str | None:
         if isinstance(self._statement, Select):
             return self._statement._repr_html_()
         return None
-    
-    
-    def __len__(self) -> int:
-        return len(self._args)
 
 
 class Statement(ABC):
@@ -276,12 +286,12 @@ class Select(Statement):
 
     def fetchmany_iterator(self, batch_size: int) -> Generator[list[SqlRow], None, None]:
         """
-        Yields all rows in batches, each batch in its own transaction.
+        Yields all rows in batches within a single transaction.
         
         Args:
             batch_size (int): Size of each batch
 
-        Examples:
+        Example:
 
         ```python
         with table.transaction():
@@ -290,8 +300,8 @@ class Select(Statement):
         ```
         """
         if not self._connection.in_transaction():
-            raise OutsideTransactionError("To use the `fetchall_iterator()` method you have \
-                    to keep open the transaction of the table")
+            raise OutsideTransactionError("To use the `fetchall_iterator()` method you have "
+                    "to keep open the transaction of the table")
         
         query, exec_args = self.build()
 
@@ -306,19 +316,18 @@ class Select(Statement):
         """ 
         Select statement rows iterator
 
-        Examples:
+        Example:
         
         ```python
         with table.transaction():
-            # here `then` is used to link back to the `select` instance from `where` object
-            for row in table.select.where.gt("Age", 30).then: 
+            for row in table.select.where.gt("Age", 30):
                 process_row(row)
         ```
         """
         
         if not self._connection.in_transaction():
-            raise OutsideTransactionError("To use the __iter__ method you have \
-                to keep open the transaction of the table")
+            raise OutsideTransactionError("To use the `__iter__` method you have "
+                "to keep open the transaction of the table")
         
         query, exec_args = self.build()
         

sqlengine/schema.py

@@ -62,15 +62,9 @@ def get_database_schemas(database : str) -> list[Schema]:
         cursor = conn.cursor()
         names  = get_database_tablenames(database, cursor)
         
-        schemas : list[Schema] = []
+        schemas = (get_table_schema(database, table_name, cursor) for table_name in names)
         
-        for tablename in names:
-            schema = get_table_schema(database, tablename, cursor)
-            
-            if schema:
-                schemas.append(schema)
-
-    return schemas
+    return [sh for sh in schemas if sh]
 
 
 def table_from_schema(database : str, schema : Schema, **kwargs) -> SqlTableMixin:

sqlengine/sqltable.py

@@ -24,7 +24,7 @@ class SqlTableMixin:
     Lightweight wrapper for SQLite3 tables
     
     Args:
-        database (str): database filename to connect to. If it not exists - will create new one first.
+        database (str): database filename to connect to. If it does not exists - will create new one first.
             If `":memory:"` is passed, then database will be set in memory and you will have to
             create table manually with `create_table()` method inside `transaction()` block.
         force_drop (bool): If `True` - will drop existing table.
@@ -37,7 +37,7 @@ class SqlTableMixin:
         __types__ (list[ColumnType]): Column types of the table
         __primary__ (list[str]): List of primary keys
 
-    Examples:
+    Example:
     ```python
     from sqlengine import SqlTableMixin, Primary
     
@@ -189,7 +189,7 @@ class SqlTableMixin:
         Args:
             autocommit (bool): If `True`, will commit changes at the end of transaction
         
-        Examples:
+        Example:
             
         ```python
         with table.transaction():
@@ -209,7 +209,7 @@ class SqlTableMixin:
             *args (SqlValue): Arguments in order of declared __columns__
             **kwargs (SqlValue): Column to value mapping
 
-        Examples:
+        Example:
 
         ```python
         table = MyTable("mydb.db")
@@ -397,7 +397,7 @@ class SqlTableMixin:
         """ 
         UPDATE statement builder and executor 
         
-        Examples:
+        Example:
         
         ```python
         table.update.set("City", "Karaganda").where.eq("Country", "Czech Republic").then.execute()
@@ -411,7 +411,7 @@ class SqlTableMixin:
         """ 
         DELETE statement builder and executor 
         
-        Examples:
+        Example:
         
         ```python
         table.delete.where.eq("ID", 0).then.execute()
@@ -425,7 +425,7 @@ class SqlTableMixin:
         """ 
         SELECT statement builder and fetcher
 
-        Examples:
+        Example:
         
         ```python
         table.select("Email").where.eq("SupportRepId", 3).then.aggregate("COUNT").fetchone()

sqlengine/utils/connection.py

@@ -25,7 +25,7 @@ def shared_connection(*args : SqlTableMixin, autocommit : bool = True, **connect
         **connection_params (dict): Params to create connections with. This argument will be shared
             across different connections. Reference: https://docs.python.org/3/library/sqlite3.html#sqlite3.connect
     
-    Examples:
+    Example:
 
     ```python
     from sqlengine.utils import shared_connection

sqlengine/utils/convert.py

@@ -4,6 +4,7 @@ from typing import Generator
 from ..sqltable import SqlTableMixin
 from .._internal.statements import Where, Select
 from .._internal.types import SqlValue
+from ..exceptions import OutsideTransactionError, SqlEngineError
 
 
 def _get_select(builder : Select | Where[Select] | SqlTableMixin) -> Select:
@@ -30,16 +31,16 @@ def to_csv(
     Args:
         builder (Select | Where[Select] | SqlTableMixin): Object to convert to csv
         filename (str): Path to write to
-        stream_bach_size (int | None): If not None or 0, will stream all rows to csv in batches of provided size
+        stream_batch_size (int | None): If not None or 0, will stream all rows to csv in batches of provided size
     """
     
     builder = _get_select(builder)
 
     if builder._aggregate:
-        raise AssertionError("Aggregated queries are not supported")
+        raise SqlEngineError("Aggregated queries are not supported")
     
     if stream_batch_size and not builder._connection.in_transaction():
-        raise RuntimeError("To stream to csv you have to keep open the `transaction`")
+        raise OutsideTransactionError("To stream to csv you have to keep open the `transaction`")
     
     columns = builder._resolve_columns()
     
@@ -66,19 +67,19 @@ def to_dicts(builder : Select | Where[Select] | SqlTableMixin) -> list[dict[str,
     Returns:
         out (list[dict[str, SqlValue]]): list of rows mappings
     
-    Examples:
+    Example:
 
     ```python
     import pandas as pd
     
-    df = pd.DataFrame(to_dict(table))
+    df = pd.DataFrame(to_dicts(table))
     ```
     """
     
     builder = _get_select(builder)
 
     if builder._aggregate:
-        raise AssertionError("Aggregated queries are not supported")
+        raise SqlEngineError("Aggregated queries are not supported")
     
     columns = builder._resolve_columns()
     rows = builder.fetchall()
@@ -95,12 +96,12 @@ def to_dicts_stream(
 
     Args:
         builder (Select | Where[Select] | SqlTableMixin): Object to convert to list of dicts
-        batch_size (int): Size of each yiedled batch
+        batch_size (int): Size of each yielded batch
 
     Yields:
         batch (list[dict[str, SqlValue]]): list of rows mappings
     
-    Examples:
+    Example:
 
     ```python
     import pandas as pd
@@ -108,7 +109,7 @@ def to_dicts_stream(
     df = pd.DataFrame(columns=table.columns)
     
     with table.transaction():
-        for batch in to_dict_stream(table, 100):
+        for batch in to_dicts_stream(table, 100):
             df = pd.concat([df, pd.DataFrame(batch)], axis=0)
     
     df.set_index("ID", inplace=True)
@@ -118,10 +119,10 @@ def to_dicts_stream(
     builder = _get_select(builder)
 
     if builder._aggregate:
-        raise AssertionError("Aggregated queries are not supported")
+        raise SqlEngineError("Aggregated queries are not supported")
     
     if not builder._connection.in_transaction():
-        raise RuntimeError("To stream to csv you have to keep open the `transaction`")
+        raise OutsideTransactionError("To stream to csv you have to keep open the `transaction`")
     
     columns = builder._resolve_columns()
 

{sqlengine_lite-2.2.1.dist-info → sqlengine_lite-2.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlengine-lite
-Version: 2.2.1
+Version: 2.2.2
 Summary: Cute sqlite3 wrapper for sql tables
 Project-URL: Homepage, https://github.com/suffermuffin/SQL-Engine
 Project-URL: Repository, https://github.com/suffermuffin/SQL-Engine.git
@@ -10,38 +10,33 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
-- [Sql-Engine](#sql-engine)
-  - [Features](#features)
-  - [Purpose](#purpose)
-  - [Installation](#installation)
-  - [Env](#env)
-- [Quick Start](#quick-start)
-  - [Table Declaration](#table-declaration)
-  - [Instantiation](#instantiation)
-  - [Row insertion](#row-insertion)
-  - [Jupyter view](#jupyter-view)
-  - [Select Query](#select-query)
-  - [Update Query](#update-query)
-  - [Delete Query](#delete-query)
-  - [Transaction](#transaction)
-  - [Get Item](#get-item)
-  - [Custom Types](#custom-types)
-  - [Csv Converter](#csv-converter)
-  - [Pandas-like Converter](#pandas-like-converter)
-- [Full Documentation](#full-documentation)
+<p align="center">
+<a href="https://github.com/suffermuffin/SQL-Engine/actions/workflows/test.yml?query=event%3Apush">
+    <img src="https://github.com/suffermuffin/SQL-Engine/actions/workflows/test.yml/badge.svg?event=push&branch=main" alt="Tests">
+</a>
+<a href="https://github.com/suffermuffin/SQL-Engine/actions?query=workflow%3APublish">
+    <img src="https://github.com/suffermuffin/SQL-Engine/actions/workflows/publish.yml/badge.svg" alt="Publishing">
+</a>
+<a href="https://pypi.org/project/sqlengine-lite/">
+    <img alt="PyPI" src="https://img.shields.io/pypi/v/sqlengine-lite?logoSize=amd&labelColor=black&color=royalblue">
+</a>
+</p>
 
 
-# Sql-Engine
+# SqlEngine
 
-My Sql-Engine is a cute little wrapper for `sqlite3` table manipulations without any third party dependencies.
+My SqlEngine is a cute little wrapper for `sqlite3` table manipulations without any third party dependencies.
+
+
+[**Home Page**](https://github.com/suffermuffin/SQL-Engine) | [**Installation**](#installation) | [**Quick Start**](#quick-start) | [**Documentation**](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/index.md)
 
 
 ## Features
 
-Abstracts SQL queries into tiny little methods like, `insert`, `insert_many`, `upsert`, and not so little and tiny query builders a-la `select`, `delete`, `update`, etc. Sql-Engine also provides bulk insertion and transaction methods, like `insert_many` and `select.fetchmany_iterator`. Methods can be executed in transaction mode thanks to `transaction` context manager.
+SqlEngine abstracts SQL queries into tiny little methods like `insert`, `insert_many`, `upsert`, and not so tiny (but still cute and little) query builders like `select`, `delete` and `update`. SqlEngine also provides bulk insertion with `insert_many` and transaction operations like `select.fetchmany_iterator`. Methods can be executed either in transaction mode (thanks to `transaction` context manager) or right on the spot.
 
 
-Sql-Engine implements Jupyter integration and dynamic schema building. You can easily instantiate existing database table and view it in cute little html representation.
+SqlEngine implements Jupyter integration and dynamic schema building. You can easily instantiate existing database table and view it in a cute little html representation.
 
 ```py
 from sqlengine import schema
@@ -74,66 +69,40 @@ table.select("InvoiceId", "CustomerId", "BillingAddress", "BillingCountry", "Tot
 
 ## Purpose
 
-It's a tiny little modern ORM-like that lets you prototype your databases locally with great flexibility. Also, it can be used in production apps to store and retrieve data, because all select, update, delete queries are parametrized. But it does not restrict you from using your own queries which might not be paramerized with methods like `select.custom()` and `where.custom()`.
+It's a tiny little modern ORM-like that lets you prototype your databases locally with great flexibility. Also, it can be used in production apps to store and retrieve data, because all select, update, delete queries are parametrized. But it does not restrict you from using your own queries which might not be parameterized with methods like `select.custom()` and `where.custom()`. Flexibility is a go to for this library.
 
-And last (but not least) is data inspection. If you need to quickly inspect existing .db file but don't want to install yet another heavy ORM with a lot of unused dependencies, you might look into Sql-Engine, as it uses only native python modules.
+And last (but not least) is data inspection. If you need to quickly inspect existing .db file but don't want to install yet another heavy ORM with a lot of unused dependencies and features, you might look into SqlEngine, as it uses only native python modules, implements dynamic schema builder and has a good synergy with Jupyter Notebook.
 
 
 ## Installation
 
-To install `sqlengine`, you can use `pip`:
+To install SqlEngine, you can use `pip`:
 
-```sh
+```bash
 pip install sqlengine-lite
 ```
 
 ## Env
 
-You may set environment variable for logging. By default it's `WARNING`.
+You can set environment variable for logging. By default it's `WARNING`.
 
 ```console
 SQL_ENGINE_LOG_LEVEL=INFO
 ```
 
-# Quick Start
-
-All you have to do to create your own cute little table is to [inherit](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/table_declaration.md#class-declaration) `SqlTableMixin` class or to create your own [schema](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/table_declaration.md#schema-declaration) and declare desired properties of your table's columns. They are:
 
+# Quick Start
 
-_Name of the table that will be used in queries. If omitted in inherited class declaration, then it will take the class name._
-```py
-__tablename__ : Optional[str]
-```
-
-_Column names of the table_
-```py
-__columns__ : list[str] 
-```
-
-_Column types of the table_
-```py
-__types__ : list[SqlType | str] 
-```
-
-_List of primary keys_
-```py
-__primary__ : list[str] 
-```
+Here lays everything you need to know to start working with SqlEngine. For detailed usage, API reference, and advanced examples, see the [full documentation](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/index.md).
 
 ## Table Declaration
 
-More details at [Declaration](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/table_declaration.md#table-declaration).
+All you have to do to create your own cute little table is to [inherit](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/table_declaration.md#class-declaration) `SqlTableMixin` class or to create your own [schema](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/table_declaration.md#schema-declaration) and declare desired types of your table's columns.
+
 
 ```py
 from sqlengine import SqlTableMixin, Primary
 
-# Helper constants for column names
-ID         = "ID"
-Name       = "Name"
-Occupation = "Occupation"
-Salary     = "Salary"
-
-
 class Employees(SqlTableMixin):
 
     ID         : Primary[int]
@@ -143,35 +112,35 @@ class Employees(SqlTableMixin):
 
 ```
 
+More details at [Declaration](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/table_declaration.md#table-declaration).
+
 ## Instantiation
 
-More details at [Instantiation](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/table_declaration.md#table-instantiation).
+Create an instance of the table class with provided path to create or connect to. `force_drop=True` to overwrite existing table if it exists.
 
 ```py
-# Create an instance of the table class 
-# with provided path to create or connect to
-# `force_drop=True` to overwrite existing table if exists
-
 table = Employees("temp/data.db", force_drop=True)
 ```
 
+More details at [Instantiation](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/table_declaration.md#table-instantiation).
+
 ## Row insertion
 
-```py
-# Insert one row
+Insert one row in a `*args` style.
 
+```py
 table.insert(1, "John Doe", "Software Engineer", 75000.0)
 ```
 
-```py
-# Use kwargs mapping to insert/upsert one row
+Use **kwargs mapping** to insert/upsert one row
 
+```py
 table.insert(2, salary=80000.0, name="Jane Smith", occupation="Data Scientist")
 ```
 
-```py
-# Bulk insert multiple rows
+Bulk insert multiple rows.
 
+```py
 employees_data = [
     (3, "Alice Johnson", "Product Manager", 90000.0),
     (4, "Bob Brown", "Project Manager", 78000.0),
@@ -187,17 +156,17 @@ table.insert_many(employees_data)
 ```
 
 
-```py
-# Upsert one row
+Upsert one row.
 
+```py
 table.upsert(1, "Jane Doe", "Data Scientist", 80000.0)
 ```
 
 ## Jupyter view
 
-```py
-# Inspect tables in Jupyter Notebook
+Inspect table in Jupyter Notebook.
 
+```py
 table
 ```
 
@@ -205,11 +174,18 @@ table
 
 ## Select Query
 
-More details at [Statements](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/statements.md).
+Helper constants for column names.
 
 ```py
-# Query select and fetch
+ID         = "ID"
+Name       = "Name"
+Occupation = "Occupation"
+Salary     = "Salary"
+```
 
+Query **select** and **fetch** in one go.
+
+```py
 table.select.where.between(ID, 3, 5).then.fetchall()
 
 # ->
@@ -218,9 +194,24 @@ table.select.where.between(ID, 3, 5).then.fetchall()
 #  (5, 'Charlie Davis', 'UI/UX Designer', 65000.0)]
 ```
 
+**Iterate** over select statements.
+
 ```py
-# Inspect query select in Jupyter
+with table.transaction():
+    for id, occupation in table.select(ID, Occupation).where.gt(Salary, 70_000):
+        print(id, occupation)
+```
 
+```console
+1 Data Scientist
+3 Product Manager
+4 Project Manager
+6 DevOps Engineer
+```
+
+Inspect select query in Jupyter.
+
+```py
 table.select(Name, Salary).where.lt(Salary, 70_000)
 ```
 
@@ -239,33 +230,32 @@ table.update(Salary, 50_000).where.eq(Name, "Eve Taylor").then.execute()
 table.delete.where.eq(ID, 5).then.execute()
 ```
 
+More details at [Statements](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/statements.md).
+
 ## Transaction
 
-More details at [Transaction](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/transactions.md).
+Operate within a transaction
 
 ```py
-# Operate within a transaction
 
 with table.transaction():
     for row in employees_data:
         table.upsert(*row)
 ```
 
+More details at [Transaction](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/transactions.md).
+
 ## Get Item
 
-More details at [Syntax Sugar](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/syntax_sugar.md).
+Fetch row by primary key.
 
 ```py
-# Fetch row by primary key
-
-table[9]
-
-# -> (9, 'Grace Hall', 'Marketing Manager', 68000.0)
+table[9] # -> (9, 'Grace Hall', 'Marketing Manager', 68000.0)
 ```
 
-```py
-# Fetch slice by integer primary key
+Fetch slice by integer primary key.
 
+```py
 table[4:10:2]
 
 # -> 
@@ -274,9 +264,11 @@ table[4:10:2]
 #  (8, 'Frank White', 'Quality Assurance', 53000.0)]
 ```
 
+More details at [Syntax Sugar](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/syntax_sugar.md).
+
 ## Custom Types
 
-More details at [Custom Types](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/custom_types.md).
+Declare your own non-native SQL type to be compatible with sqlite3.
 
 ```py
 from datetime import datetime
@@ -305,36 +297,68 @@ class ReservationIndex(SqlTableMixin):
 
 table = ReservationIndex("temp/data.db")
 
-table.insert(1, "loft_1", DateTime.now(), None)
+table.insert(
+    user_id=1, 
+    room_id="loft_1", 
+    time_at=DateTime.now()
+)
 table
 ```
 
 <table style="border-collapse: collapse; font-size: 14px;"><caption style="font-size: 18px; font-weight: bold;">ReservationIndex</caption><thead><tr><td style="border: 1px solid #555; text-align: center;">user_id</td><td style="border: 1px solid #555; text-align: center;">room_id</td><td style="border: 1px solid #555; text-align: center;">time_at</td><td style="border: 1px solid #555; text-align: center;">user_name</td></tr></thead><tbody><tr><td style="border: 1px solid #000; text-align: center;">1</td><td style="border: 1px solid #000; text-align: center;">loft_1</td><td style="border: 1px solid #000; text-align: center;">2026-05-29 21:29:00</td><td style="border: 1px solid #000; text-align: center;">None</td></tr></tbody></table>
 
+More details at [Custom Types](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/custom_types.md).
+
+## Pure SQL
+
+Use SQL queries directly.
+
+```py
+with table.transaction(autocommit=False):
+    table.conn.execute("DELETE FROM ReservationIndex WHERE user_id = 1;")
+    table.commit()
+```
+
+Same as:
+
+```py
+table.conn.execute("DELETE FROM ReservationIndex WHERE user_id = 1;")
+```
+
+```py
+table
+```
+
+<table style="border-collapse: collapse; font-size: 14px;"><caption style="font-size: 18px; font-weight: bold;">ReservationIndex</caption><thead><tr><td style="border: 1px solid #555; text-align: center;">user_id</td><td style="border: 1px solid #555; text-align: center;">room_id</td><td style="border: 1px solid #555; text-align: center;">time_at</td><td style="border: 1px solid #555; text-align: center;">user_name</td></tr></thead><tbody></tbody></table>
+
 ## Csv Converter
 
+Save table to csv.
+
 ```py
-# Save table to csv
 from sqlengine.utils import to_csv
 
 to_csv(table, "temp/table.csv")
 ```
 
+Save query result to csv.
+
 ```py
-# Save query result to csv
 to_csv(table.select.where.gt(Salary, 70_000), "temp/query.csv")
 ```
 
+Stream big tables or query results to csv.
+
 ```py
-# Stream to csv
 with table.transaction():
     to_csv(table, "temp/query.csv", stream_batch_size=1000)
 ```
 
 ## Pandas-like Converter
 
+Convert tables or query results to pandas **DataFrame** in one shot.
+
 ```py
-# via one shot
 import pandas as pd
 from sqlengine.utils import to_dicts
 
@@ -342,8 +366,9 @@ df = pd.DataFrame(to_dicts(table))
 df.set_index("ID", inplace=True)
 ```
 
+Or stream them via generator.
+
 ```py
-# via generator
 import pandas as pd
 from sqlengine.utils import to_dicts_stream
 
@@ -356,6 +381,34 @@ with table.transaction():
 df.set_index("ID", inplace=True)
 ```
 
-# Full Documentation
+# Contributions
+
+Your impact is welcome. Install module from source if you want to contribute:
+
+```bash
+git clone https://github.com/suffermuffin/SQL-Engine.git
+cd SQL-Engine
+```
+
+Use `uv` to sync dependencies and checkout to your new branch:
+
+```bash
+uv sync
+git checkout -b "<your_feature_or_fix_name>"
+```
+
+Don't forget to run tests after the implementation:
+
+```bash
+uv run python -m unittest discover -s tests
+```
+
+And update api documentation with your docstrings:
+
+```bash
+pydoc-markdown
+```
+
+# License
 
-For detailed usage, API reference, and advanced examples, see the [full documentation](https://github.com/suffermuffin/SQL-Engine/blob/main/docs/index.md).
+This project is licensed under the terms of the [MIT license](https://github.com/suffermuffin/SQL-Engine/blob/main/LICENSE).

sqlengine_lite-2.2.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+sqlengine/__init__.py,sha256=_t3mutixVp60g1MwD6BZ6WcvXZPFz7JkV29nXXl1bOw,305
+sqlengine/exceptions.py,sha256=Sd12r8dHgtKr6RKUaiHNhaEpdJr3Jr-JXePwrBQojC4,506
+sqlengine/schema.py,sha256=SL-7eXib56wIVHSgykqMJKZGRPJuOffpwA0GJEgChSc,3593
+sqlengine/sqltable.py,sha256=ZgkPQi5L1IGHauamTSjqyKVGNMKHCKmt3tEGTI-pCnY,16197
+sqlengine/_internal/__init__.py,sha256=9cQIPDgLssRJNeROpuDYA0rJzY9B_N9VsY4rJbgzBnk,159
+sqlengine/_internal/connection_manager.py,sha256=j4H7BiPu7iUxqOSRMmApgGnCY9dRBdL4javwMwAi_BU,8522
+sqlengine/_internal/repr.py,sha256=PEwC3MdOoTE8ORvcVXTCmY502boJfr5V2LU5jJ6qWG0,1478
+sqlengine/_internal/sqlgen.py,sha256=b8usEqBAX5JDEdMR6Xeaona0ZuOi7vtptl858qXhD78,3473
+sqlengine/_internal/statements.py,sha256=8D6uZCwm4iMwfq0Lzg5-Z91x68xN874xQbHyZyFPBKE,12876
+sqlengine/_internal/types.py,sha256=bA-tsS8r13pvRB3M13wFNsd3Fc9KAaqGW47aXhkKkDQ,3265
+sqlengine/utils/__init__.py,sha256=EGg576qs61VsXlXd1bxF0oDytlmpcgqouVLdPxwqTrI,173
+sqlengine/utils/connection.py,sha256=wnA21QCUd7meRHL114ZzghchNIgvmq-cEmIJ-8L_ozQ,3118
+sqlengine/utils/convert.py,sha256=8bUNdxNNNkBnUIcTNkLGqA9h_X-D8BHtssHhe0UMPx0,3782
+sqlengine_lite-2.2.2.dist-info/licenses/LICENSE,sha256=aepvve4t1ho5uHMQG88dErp5L5CgoNAXctIjMdoceqY,1069
+sqlengine_lite-2.2.2.dist-info/METADATA,sha256=2WfgmOiu-lq7b6fBamCTtVhuVmYNHwCDuujYz1H9WL0,22586
+sqlengine_lite-2.2.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sqlengine_lite-2.2.2.dist-info/top_level.txt,sha256=KG_FG0LCB_mIEu2qJ5LGLQMpan4QmF5d8xLEcqTghCE,10
+sqlengine_lite-2.2.2.dist-info/RECORD,,

sqlengine_lite-2.2.1.dist-info/RECORD

@@ -1,18 +0,0 @@
-sqlengine/__init__.py,sha256=_t3mutixVp60g1MwD6BZ6WcvXZPFz7JkV29nXXl1bOw,305
-sqlengine/exceptions.py,sha256=Sd12r8dHgtKr6RKUaiHNhaEpdJr3Jr-JXePwrBQojC4,506
-sqlengine/schema.py,sha256=HUk11gqOSzQTdiKBYU65EEQ52iCbUj3fxv3jigi1tG8,3692
-sqlengine/sqltable.py,sha256=FOwXyTghcIxF8vhxMgzFeF6wAZNRjVt6r7Ebhqs-iJ0,16198
-sqlengine/_internal/__init__.py,sha256=9cQIPDgLssRJNeROpuDYA0rJzY9B_N9VsY4rJbgzBnk,159
-sqlengine/_internal/connection_manager.py,sha256=2ooDsAUvSfXTBpUJtNDS2GIO96tJo1GnE_R7dRBVflY,8466
-sqlengine/_internal/repr.py,sha256=PEwC3MdOoTE8ORvcVXTCmY502boJfr5V2LU5jJ6qWG0,1478
-sqlengine/_internal/sqlgen.py,sha256=b8usEqBAX5JDEdMR6Xeaona0ZuOi7vtptl858qXhD78,3473
-sqlengine/_internal/statements.py,sha256=ntJrOeomPW15KowXUbnma9_ah-H5_ZmWKjemCIsf3Rw,12395
-sqlengine/_internal/types.py,sha256=bA-tsS8r13pvRB3M13wFNsd3Fc9KAaqGW47aXhkKkDQ,3265
-sqlengine/utils/__init__.py,sha256=EGg576qs61VsXlXd1bxF0oDytlmpcgqouVLdPxwqTrI,173
-sqlengine/utils/connection.py,sha256=H86Y2PUJcTIc9iD398MJoRR-IyMYSVjOSfu_bk9UuoM,3119
-sqlengine/utils/convert.py,sha256=Il5KAbc0Mbe2SIxBWyvj9rJ68XTJmpDFboJc1vifaaI,3694
-sqlengine_lite-2.2.1.dist-info/licenses/LICENSE,sha256=aepvve4t1ho5uHMQG88dErp5L5CgoNAXctIjMdoceqY,1069
-sqlengine_lite-2.2.1.dist-info/METADATA,sha256=XAAXT6IKmRIUkYtVkqij11U1W5UMZNwjfGg9sgbT81w,20593
-sqlengine_lite-2.2.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-sqlengine_lite-2.2.1.dist-info/top_level.txt,sha256=KG_FG0LCB_mIEu2qJ5LGLQMpan4QmF5d8xLEcqTghCE,10
-sqlengine_lite-2.2.1.dist-info/RECORD,,