sqlengine-lite 2.1.0__tar.gz → 2.1.1__tar.gz

{sqlengine_lite-2.1.0 → sqlengine_lite-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlengine-lite
-Version: 2.1.0
+Version: 2.1.1
 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

{sqlengine_lite-2.1.0 → sqlengine_lite-2.1.1}/pyproject.toml

@@ -1,17 +1,20 @@
 [project]
 name = "sqlengine-lite"
-version = "2.1.0"
+version = "2.1.1"
 description = "Cute sqlite3 wrapper for sql tables"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = []
 
 [tool.setuptools]
-packages = ["sqlengine"]
+
 
 [tool.setuptools.package-dir]
 "" = "src"
 
+[tool.setuptools.packages.find]
+where = ["src"]
+
 [build-system]
 requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"

sqlengine_lite-2.1.1/src/sqlengine/utils/__init__.py

@@ -0,0 +1,5 @@
+from .connection import shared_connection
+from .statements import Select, Delete, Update
+from .repr       import to_csv
+
+__all__ = ["shared_connection", "Select", "Delete", "Update", "to_csv"]

sqlengine_lite-2.1.1/src/sqlengine/utils/connection.py

@@ -0,0 +1,87 @@
+import sqlite3
+import logging
+import os
+
+from contextlib import contextmanager
+from ..sqltable import SqlTableMixin
+
+logger = logging.getLogger("sqlengine")
+logger.setLevel(os.getenv("SQL_ENGINE_LOG_LEVEL", "WARNING").upper())
+
+
+@contextmanager
+def shared_connection(*args : SqlTableMixin, autocommit : bool = True, **connection_params):
+    """
+    Creates shared connection across one or more databases for multiple tables by
+    manipulating their transaction attributes
+
+    Args:
+        *args (SqlTableMixin): tuple of instances of table classes inherited from `SqlTableMixin`
+        autocommit (bool): If `True`, will commit changes at the end of transaction
+        **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:
+
+        >>> from sqlengine.utils import shared_connection
+        >>> with shared_connection(table1, table2, **table1.connection_params):
+        >>>     for (id1,), (id2, temp) in zip(table1.select("ID").limit(20), table2.select("ID", "Temperature").limit(20)):
+        >>>         if id1 == id2:
+        >>>             table.update.where.eq("ID", id2).then.set("Salary", temp).execute()
+    """
+
+    tables_in_trans = [(f"{table.__class__.__name__=}, {table.tablename=}, {table.database=}") for table in args if table.in_transaction()]
+    
+    if tables_in_trans:
+        raise RuntimeError(f"Tables {tables_in_trans} are already in transaction")
+    
+    unique_databases = set(table.database for table in args)
+    database_map : dict[str, list[SqlTableMixin]] = {}
+    
+    for db in unique_databases:
+        database_map[db] = [table for table in args if table.database == db]
+
+    connections : list[sqlite3.Connection] = []
+
+    for database, tables in database_map.items():
+        
+        con = sqlite3.connect(database, **connection_params)
+        connections.append(con)
+        
+        for table in tables:
+            table_cur = con.cursor()
+            setattr(table, "_trans", con)
+            setattr(table, "_trans_cursor", table_cur)
+            table._is_managed_transaction = True
+
+    logger.debug(f"Starting shared transaction across {len(database_map)} databases")
+    
+    try:
+        yield
+    
+    except Exception as e:
+        logger.error(f"Error while in shared transaction: {e}")
+        logger.debug(e, exc_info=True)
+        
+        for con in connections:
+            con.rollback()
+        
+        raise e
+    
+    else:
+        if autocommit:
+            for con in connections:
+                con.commit()
+    
+    finally:
+        
+        for table in args:
+            table._is_managed_transaction = False
+            table.tx_cursor.close()
+            delattr(table, "_trans_cursor")
+            delattr(table, "_trans")
+        
+        for con in connections:
+            con.close()
+        
+        logger.debug("Shared transaction finished")

sqlengine_lite-2.1.1/src/sqlengine/utils/repr.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+from html import escape
+from typing import Sequence, TYPE_CHECKING
+
+import csv
+
+if TYPE_CHECKING:
+    from .statements import Select, Where
+    from ..sqltable  import SqlTableMixin
+
+from .types import SqlRow
+
+
+def to_html(tablename : str, columns : list[str], repr_rows : Sequence[SqlRow], limit : int = 25) -> str:
+
+    tablestyle     = "<table style=\"border-collapse: collapse; font-size: 14px;\">"
+    tablenamestyle = "<caption style=\"font-size: 18px; font-weight: bold;\">{}</caption>"
+    colstyle       = "<td style=\"border: 1px solid #555; text-align: center;\">{}</td>"
+    cellstyle      = "<td style=\"border: 1px solid #000; text-align: center;\">{}</td>"
+    morestyle      = "<td colspan=\"{}\" style=\"text-align:center;color:#888;font-style:italic;padding:8px;\">... more rows ...</td>"
+    
+    cols      = [colstyle.format(escape(col)) for col in columns]
+    tablename = tablenamestyle.format(escape(tablename))
+    more      = morestyle.format(len(columns))
+
+    html = [
+        tablestyle,
+        tablename,
+            "<thead>",
+                "<tr>",
+                    *cols,
+                "</tr>",
+            "</thead>",
+        "<tbody>",
+    ]
+
+    for row in repr_rows[:limit]:
+        values = [cellstyle.format(escape(str(val))) for val in row]
+        
+        html.extend([
+            "<tr>",
+                *values,
+            "</tr>"
+        ])
+    
+    if len(repr_rows) > limit:
+        html.extend([
+        "<tr>",
+            more,
+        "</tr>"
+      ])
+    
+    html.extend([
+        "</tbody>",
+        "</table>",
+    ])
+
+    return "".join(html)
+
+
+def to_csv(builder : Select | Where[Select] | SqlTableMixin, path : str) -> None:
+    
+    from ..sqltable  import SqlTableMixin
+    from .statements import Where
+
+    match builder:
+        case Where():
+            builder = builder.then
+        case SqlTableMixin():
+            builder = builder.select
+
+    if builder._aggregate:
+        raise AssertionError("Aggregated queries are not supported")
+    
+    columns   = builder._table.columns if len(builder._columns) == 0 or "*" in builder._columns else builder._columns
+    repr_rows = builder.fetchall()
+
+    with open(path, 'w', newline='') as file:
+        writer = csv.writer(file)
+        writer.writerow(columns)
+        writer.writerows(repr_rows)

sqlengine_lite-2.1.1/src/sqlengine/utils/sqlgen.py

@@ -0,0 +1,111 @@
+from typing import Sequence
+
+
+def format_list(items : Sequence | set, brackets : bool = True) -> str:
+    """ Formats list into `(item1, item2, ...)` format """
+    items_str = ', '.join([str(i) for i in items])
+    if not brackets: 
+        return items_str
+    return f'({items_str})'
+
+
+def create_table(
+        tablename: str,
+        columns  : list[str],
+        types    : list[str],
+        primary  : list[str]
+    ) -> str:
+
+    columns_types = format_list([
+        f'{col} {dtype}' for col, dtype 
+        in zip(columns, types)], brackets=False)
+    
+    primary_keys = format_list(primary)
+    
+    return (
+        f"CREATE TABLE IF NOT EXISTS {tablename} "
+        f"({columns_types}, PRIMARY KEY {primary_keys});"
+    )
+
+
+def drop_table(tablename : str) -> str:
+    return f"DROP TABLE IF EXISTS {tablename}"
+
+
+def values_placeholder(n_values : int) -> str:
+    """ Creates placeholder `(?, ?, ?, ...)` with "?" `n_values` times """
+    return format_list(['?']*n_values)
+
+
+def bulk_placeholder(n_values : int, n_rows : int) -> str:
+    """ Creates placeholders `(?, ?, ..), (?, ?, ..), ...` for each row """
+    place_holder = values_placeholder(n_values)
+    return f"{format_list([place_holder]*n_rows, False)}"
+
+
+def insert(tablename : str, columns : list[str], values : str) -> str:
+    """ Creates insert query """
+    return f"INSERT INTO {tablename} {format_list(columns)} VALUES {values};"
+
+
+def insert_row(tablename : str, columns : list[str]) -> str:
+    """ Creates insert query for 1 row """
+    n_values = len(columns)
+    placeholder = values_placeholder(n_values)
+    return insert(tablename, columns, placeholder)
+
+
+def insert_many(tablename : str, columns : list[str], n_rows : int) -> str:
+    """ Creates insert query for multiple rows """
+    n_values = len(columns)
+    placeholder = bulk_placeholder(n_values, n_rows)
+    return insert(tablename, columns, placeholder)
+
+
+def delete_rows(tablename : str, where_clause : str) -> str:
+    return f"DELETE FROM {tablename} WHERE {where_clause};"
+
+
+def select(
+      tablename   : str,
+      columns     : str | list[str]  = "*",
+      where_clause: str | None       = None,
+      order_by    : str | None       = None,
+      limit       : int | str | None = None
+    ) -> str: 
+    """ Creates select query """
+    
+    _columns = columns if isinstance(columns, str) else format_list(columns, False)
+    
+    query  = f"SELECT {_columns} FROM {tablename}"
+    query += f" WHERE {where_clause}" if where_clause else ""
+    query += f" ORDER BY {order_by}"  if order_by     else ""
+    query += f" LIMIT {limit}"        if limit        else ""
+    query += ";"
+
+    return query
+
+
+def upsert(tablename : str, columns : list[str], primary_key : list[str]) -> str:
+    """
+    Creates query to upsert (update or insert) row based on `primary_key`
+
+    Args:
+        tablename (str): name of the table in db
+        columns (list[str]): list of table columns
+        primary_key (list[str]): list of primary keys
+    """
+    placeholder  = values_placeholder(len(columns))
+    non_primary  = set(columns) - set(primary_key)
+    updated_list = [f"{col}=excluded.{col}" for col in non_primary]
+    
+    columns_str = format_list(columns)
+    updated_str = format_list(updated_list, False)
+    primary_str = format_list(primary_key)
+
+    query = (
+        f"INSERT INTO {tablename} {columns_str} VALUES {placeholder} "
+        f"ON CONFLICT {primary_str} "
+        f"DO UPDATE SET {updated_str};"
+    )
+    return query

sqlengine_lite-2.1.1/src/sqlengine/utils/statements.py

@@ -0,0 +1,400 @@
+from __future__ import annotations
+from typing     import Sequence, Literal, Generator, Self, TYPE_CHECKING
+from abc        import ABC, abstractmethod
+
+if TYPE_CHECKING:
+    from .statements import Statement 
+    from ..sqltable  import SqlTableMixin
+
+from . import sqlgen as sql
+from .types import SqlValue, SqlRow
+from .repr  import to_html
+
+
+class Where[T : Statement]:
+    """ Where clause build helper """
+    
+    
+    def __init__(self, statement : T):
+        
+        self._statement = statement
+        
+        self._clause   : list[str] = []
+        self._args     : list[SqlValue] = []
+
+
+    @property
+    def then(self) -> T:
+        """ Returns upper statement object """
+        return self._statement
+    
+    
+    def __call__(self, where_clasuse : str, *args : SqlValue) -> Self:
+        """ Shortcut to custom where clause """
+        return self.custom(where_clasuse, *args)
+
+    
+    def op(self, column : str, value : SqlValue, operator : str) -> Self:
+        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` """
+        joined = f" {lop} ".join(self._clause)
+        self._clause = [f"({joined})"]
+        return self
+
+    
+    def eq(self, column : str, value : SqlValue) -> Self:
+        return self.op(column, value, "=")
+
+    
+    def neq(self, column : str, value : SqlValue) -> Self:
+        return self.op(column, value, "!=")
+    
+    
+    def gt(self, column : str, value : SqlValue) -> Self:
+        return self.op(column, value, ">")
+    
+    
+    def gte(self, column : str, value : SqlValue) -> Self:
+        return self.op(column, value, ">=")
+    
+    
+    def lt(self, column : str, value : SqlValue) -> Self:
+        return self.op(column, value, "<")
+    
+    
+    def lte(self, column : str, value : SqlValue) -> Self:
+        return self.op(column, value, "<=")
+    
+    
+    def like(self, column : str, pattern : str) -> Self:
+        """ 
+        Like operator. Pattern is a SQL wildcard pattern 
+        (i.e. `%` for any string, `_` for one character).
+        """
+        return self.op(column, pattern, "LIKE")
+    
+    
+    def is_null(self, column : str) -> Self:
+        self._clause.append(f"{column} IS NULL")
+        return self
+    
+    
+    def inverted(self) -> Self:
+        """ Invert last where clause with NOT """
+        self._clause[-1] = f"NOT ({self._clause[-1]})"
+        return self
+    
+    
+    def in_(self, column : str, values : Sequence[SqlValue]) -> Self:
+        if isinstance(values, str):
+            raise ValueError("Got string as sequence of values in in_, expected tuple/list/etc...")
+        placeholder = sql.values_placeholder(len(values))
+        self._clause.append(f"{column} IN {placeholder}")
+        self._args.extend(values)
+        return self
+    
+    
+    def between(self, column : str, start : SqlValue, stop : SqlValue) -> Self:
+        self._clause.append(f"{column} BETWEEN ? AND ?")
+        self._args.extend((start, stop))
+        return self
+    
+    
+    def custom(self, where_clause : str, *args : SqlValue) -> Self:
+        """ Add custom where clause (e.g. `where.custom("Age > ? AND Age != ?", 10, 25)`) """
+        self._clause.append(where_clause)
+        self._args.extend(args)
+        return self
+
+    
+    def build(self, lop : str = "AND") -> tuple[str, tuple[SqlValue, ...]]:
+        where_clause = f" {lop} ".join(self._clause).strip()
+        args = tuple(self._args)
+        return where_clause, args
+    
+    
+    def reset(self) -> None:
+        self._args = []
+        self._clause = []
+
+    
+    def __str__(self) -> str:
+        return self._statement.__str__()
+
+    
+    def __repr__(self) -> str:
+        return self._statement.__repr__()
+
+    
+    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):
+    """
+    Statement object that helps you build queries and execute them
+    """
+
+    __command__ : Literal["SELECT", "INSERT", "UPDATE", "DELETE"]
+
+    def __init__(self, table : SqlTableMixin) -> None:
+
+        self._table = table
+        self._where: Where[Self] = Where(self)
+
+        self._custom_query : str | None = None
+        self._custom_args  : tuple[SqlValue, ...] = ()
+    
+    
+    def custom_query(self, query : str, *args) -> Self:
+        """ Custom query that completely replaces builder's expression """
+        self._custom_query = query
+        self._custom_args  = args
+        return self
+    
+
+    def build(self) -> tuple[str, tuple[SqlValue, ...]]:
+        """ Build complete expression with sorted arguments and operations """
+        if self._custom_query:
+            return self._custom_query, self._custom_args
+        
+        where_clause, args = self._where.build()
+        query, args = self._build(where_clause, *args)
+        return query, args
+    
+
+    def reset(self) -> None:
+        """ Resets statement to reuse object """
+        self._where.reset()
+        self._custom_query = None
+        self._custom_args = ()
+        self._reset()
+    
+    
+    @property
+    def where(self) -> Where[Self]:
+        """ Where clause builder """
+        return self._where
+    
+    
+    @abstractmethod
+    def _build(self, where_clause : str, *args : SqlValue) -> tuple[str, tuple[SqlValue, ...]]:
+        pass
+
+    
+    @abstractmethod
+    def _reset(self) -> None:
+        pass
+
+
+    def __repr__(self) -> str:
+        query, args = self.build()
+        return f"{query} {args}"
+    
+
+    def __str__(self) -> str:
+        query, _ = self.build()
+        return query
+    
+
+class MutationalStatement(Statement, ABC):
+
+    
+    def execute(self) -> None:
+        query, args = self.build()
+        self._table.execute(query, *args)
+
+
+class Select(Statement):
+
+
+    def __init__(self, table : SqlTableMixin) -> None:
+        super().__init__(table)
+        
+        self._columns   : list[str] = []
+        self._order_by  : list[str] = []
+        self._aggregate : str | None = None
+        self._limit     : int | None = None
+
+
+    def __call__(self, *columns : str) -> Self:
+        return self.columns(*columns)
+    
+
+    def columns(self, *columns : str) -> Self:
+        """ Column selector """
+        self._columns.extend(columns)
+        return self
+    
+    
+    def aggregate(self, by : Literal['COUNT', 'SUM', 'AVG', 'MIN', 'MAX']) -> Self:
+        
+        if self._aggregate:
+            raise ValueError("Can't aggregate columns multiple times")
+        
+        self._aggregate = by
+        return self
+
+    
+    def order_by(self, column : str, ascending : bool = True) -> Self:
+        order = "ASC" if ascending else "DESC"
+        self._order_by.append(f"{column} {order}")
+        return self
+    
+
+    def limit(self, n : int) -> Self:
+        self._limit = n
+        return self
+    
+
+    def fetchone(self) -> SqlRow:
+        query, args = self.build()
+        return self._table.fetchone(query, *args)
+        
+
+    def fetchmany(self, size : int = 1) -> list[SqlRow]:
+        query, args = self.build()
+        return self._table.fetchmany(query, *args, size=size)
+
+    
+    def fetchall(self) -> list[SqlRow]:
+        query, args = self.build()
+        return self._table.fetchall(query, *args)
+    
+
+    def fetchmany_iterator(self, batch_size: int) -> Generator[list[SqlRow], None, None]:
+        """
+        Yields all rows in batches, each batch in its own transaction.
+        
+        Args:
+            batch_size (int): Size of each batch
+
+        Examples:
+
+            >>> with table.transaction():
+            >>>     for batch in table.select.where.gt("Age", 30).then.fetchmany_iterator(1000):
+            >>>         process_batch(batch)
+        """
+        if not self._table.in_transaction():
+            raise RuntimeError("To use the `fetchall_iterator()` method you have \
+                    to keep open the transaction of the table with `transaction()` manager")
+        
+        query, exec_args = self.build()
+
+        iter_cursor = self._table.tx_conn.cursor()
+        iter_cursor.execute(query, exec_args)
+
+        while batch := iter_cursor.fetchmany(batch_size):
+            yield batch
+
+    
+    def __iter__(self) -> Generator[SqlRow, None, None]:
+        """ Select statement rows iterator """
+        
+        if not self._table.in_transaction():
+            raise RuntimeError("To use the __iter__ method you have \
+                to keep open the transaction of the table with `transaction()` manager")
+        
+        query, exec_args = self.build()
+        
+        iter_cursor = self._table.tx_conn.cursor()
+        iter_cursor.execute(query, exec_args)
+
+        while row := iter_cursor.fetchone(): 
+            yield row
+    
+
+    def _build(self, where_clause : str, *args : SqlValue) -> tuple[str, tuple[SqlValue, ...]]:
+
+        order   = sql.format_list(self._order_by, brackets=False)
+        columns = sql.format_list(self._columns,  brackets=False)
+        
+        columns = "*" if not columns else columns
+        columns = columns if not self._aggregate else f"{self._aggregate}({columns})"
+
+        if self._limit is not None:
+            limit = "?"
+            args  = (*args, self._limit)
+        
+        else:
+            limit = None
+        
+        query = sql.select(self._table.tablename, columns, where_clause, order, limit)
+        
+        return query, args
+    
+    
+    def _reset(self) -> None:
+        self._columns   = []
+        self._order_by  = []
+        self._aggregate = None
+        self._limit     = None
+
+
+    def _repr_html_(self) -> str | None:
+        
+        if self._aggregate:
+            return None
+        
+        limit     = 26
+        columns   = self._table.columns if len(self._columns) == 0 or "*" in self._columns else self._columns
+        repr_rows = self.fetchmany(limit)
+
+        return to_html(self._table.tablename, columns, repr_rows, limit=limit-1)
+    
+
+class Delete(MutationalStatement):
+
+    
+    def _build(self, where_clause : str, *args : SqlValue) -> tuple[str, tuple[SqlValue, ...]]:
+        
+        if not where_clause:
+            raise ValueError("Delete statement must have a where clause")
+        
+        query = sql.delete_rows(self._table.tablename, where_clause)
+        return query, args
+    
+    def _reset(self) -> None:
+        pass
+    
+
+class Update(MutationalStatement):
+
+
+    def __init__(self, table : SqlTableMixin) -> None:
+        super().__init__(table)
+        self._set_clauses : list[str] = []
+        self._set_args    : list[SqlValue] = []
+
+    
+    def __call__(self, column : str, value : SqlValue) -> Self:
+        return self.set(column, value)
+
+
+    def set(self, column : str, value : SqlValue) -> Self:
+        """ Set value to a column """
+        self._set_clauses.append(f"{column} = ?")
+        self._set_args.append(value)
+        return self
+
+
+    def _build(self, where_clause : str, *args : SqlValue) -> tuple[str, tuple[SqlValue, ...]]:
+        set_clause = sql.format_list(self._set_clauses, brackets=False)
+        query = f"UPDATE {self._table.tablename} SET {set_clause} WHERE {where_clause};"
+        return query, (*self._set_args, *args)
+    
+    
+    def _reset(self) -> None:
+        self._set_clauses = []
+        self._set_args = []

sqlengine_lite-2.1.1/src/sqlengine/utils/types.py

@@ -0,0 +1,65 @@
+import sqlite3
+from typing import Protocol, Self, TypeGuard, TypedDict
+
+
+class CustomType(Protocol):
+    @classmethod
+    def from_sql(cls, sql : bytes) -> Self: 
+        """ Method that accepts bytes and returns object instance """
+        ...
+    def to_sql(self) -> str | int | float | str | bytes | None: 
+        """ Method that converts object instance to native sqlite3 value """
+        ...
+
+
+type SqlValue = str | int | float | bytes | None | CustomType
+type SqlRow   = tuple[SqlValue, ...]
+type SqlType  = type[str | int | float | bytes | CustomType]
+
+
+class Schema(TypedDict):
+    tablename : str
+    columns   : list[str]
+    types     : list[SqlType | str]
+    primary   : list[str]
+
+
+# https://docs.python.org/3/library/sqlite3.html#sqlite-and-python-types
+_TYPES_MAP : dict[type, str] = {
+    int     : "INTEGER",
+    float   : "REAL",
+    str     : "TEXT",
+    bytes   : "BLOB",
+}
+
+
+def is_custom_type(type_: SqlType) -> TypeGuard[type[CustomType]]:
+    return (
+        type_ not in (str, int, float, bytes)
+        and isinstance(type_, type)
+        and hasattr(type_, "from_sql")
+        and hasattr(type_, "to_sql")
+    )
+
+
+def register_type(cls : type[CustomType], type_name : str | None = None) -> None:
+    """ 
+    Register custom type to be able to store it in tables 
+    
+    Args:
+        cls (CustomType): Class that implements `from_sql(cls, sql : bytes) -> Self` and `
+            to_sql(self) -> str | int | float | str | bytes | None`
+        type_name (str | None): Colname that would be linked to this type
+    """
+
+    type_name = type_name if type_name else cls.__name__
+    sqlite3.register_adapter(cls, lambda x: x.to_sql())
+    sqlite3.register_converter(type_name, cls.from_sql)
+
+
+def pytype_to_sqltype(type_ : type) -> str:
+    """ Converts python type to sql type """
+    if type_ not in _TYPES_MAP:
+        raise TypeError(f"{type_} is not natively supported by sqlite3")
+    
+    return _TYPES_MAP[type_]

{sqlengine_lite-2.1.0 → sqlengine_lite-2.1.1}/src/sqlengine_lite.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlengine-lite
-Version: 2.1.0
+Version: 2.1.1
 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

{sqlengine_lite-2.1.0 → sqlengine_lite-2.1.1}/src/sqlengine_lite.egg-info/SOURCES.txt

@@ -4,6 +4,12 @@ pyproject.toml
 src/sqlengine/__init__.py
 src/sqlengine/schema.py
 src/sqlengine/sqltable.py
+src/sqlengine/utils/__init__.py
+src/sqlengine/utils/connection.py
+src/sqlengine/utils/repr.py
+src/sqlengine/utils/sqlgen.py
+src/sqlengine/utils/statements.py
+src/sqlengine/utils/types.py
 src/sqlengine_lite.egg-info/PKG-INFO
 src/sqlengine_lite.egg-info/SOURCES.txt
 src/sqlengine_lite.egg-info/dependency_links.txt