sqliter-py 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

sqliter/constants.py

@@ -0,0 +1,20 @@
+"""Define constants used in the library."""
+
+OPERATOR_MAPPING = {
+    "__lt": "<",
+    "__lte": "<=",
+    "__gt": ">",
+    "__gte": ">=",
+    "__eq": "=",
+    "__ne": "!=",
+    "__in": "IN",
+    "__not_in": "NOT IN",
+    "__isnull": "IS NULL",
+    "__notnull": "IS NOT NULL",
+    "__startswith": "LIKE",
+    "__endswith": "LIKE",
+    "__contains": "LIKE",
+    "__istartswith": "LIKE",
+    "__iendswith": "LIKE",
+    "__icontains": "LIKE",
+}

sqliter/exceptions.py

@@ -72,6 +72,12 @@ class InvalidOffsetError(SqliterError):
     )
 
 
+class InvalidOrderError(SqliterError):
+    """Raised when an invalid order value is used."""
+
+    message_template = "Invalid order value - {}"
+
+
 class TableCreationError(SqliterError):
     """Raised when a table cannot be created in the database."""
 

sqliter/query/query.py

@@ -3,20 +3,29 @@
 from __future__ import annotations
 
 import sqlite3
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union
 
-from typing_extensions import Self
+from typing_extensions import LiteralString, Self
 
+from sqliter.constants import OPERATOR_MAPPING
 from sqliter.exceptions import (
     InvalidFilterError,
     InvalidOffsetError,
+    InvalidOrderError,
     RecordFetchError,
 )
 
 if TYPE_CHECKING:  # pragma: no cover
+    from pydantic.fields import FieldInfo
+
     from sqliter import SqliterDB
     from sqliter.model import BaseDBModel
 
+# Define a type alias for the possible value types
+FilterValue = Union[
+    str, int, float, bool, None, list[Union[str, int, float, bool]]
+]
+
 
 class QueryBuilder:
     """Functions to build and execute queries for a given model."""
@@ -26,22 +35,138 @@ class QueryBuilder:
         self.db = db
         self.model_class = model_class
         self.table_name = model_class.get_table_name()  # Use model_class method
-        self.filters: list[tuple[str, Any]] = []
+        self.filters: list[tuple[str, Any, str]] = []
         self._limit: Optional[int] = None
         self._offset: Optional[int] = None
         self._order_by: Optional[str] = None
 
-    def filter(self, **conditions: str | float | None) -> Self:
+    def filter(self, **conditions: str | float | None) -> QueryBuilder:
         """Add filter conditions to the query."""
         valid_fields = self.model_class.model_fields
 
         for field, value in conditions.items():
-            if field not in valid_fields:
-                raise InvalidFilterError(field)
-            self.filters.append((field, value))
+            field_name, operator = self._parse_field_operator(field)
+            self._validate_field(field_name, valid_fields)
+
+            handler = self._get_operator_handler(operator)
+            handler(field_name, value, operator)
 
         return self
 
+    def _get_operator_handler(
+        self, operator: str
+    ) -> Callable[[str, Any, str], None]:
+        handlers = {
+            "__isnull": self._handle_null,
+            "__notnull": self._handle_null,
+            "__in": self._handle_in,
+            "__not_in": self._handle_in,
+            "__startswith": self._handle_like,
+            "__endswith": self._handle_like,
+            "__contains": self._handle_like,
+            "__istartswith": self._handle_like,
+            "__iendswith": self._handle_like,
+            "__icontains": self._handle_like,
+            "__lt": self._handle_comparison,
+            "__lte": self._handle_comparison,
+            "__gt": self._handle_comparison,
+            "__gte": self._handle_comparison,
+            "__ne": self._handle_comparison,
+        }
+        return handlers.get(operator, self._handle_equality)
+
+    def _validate_field(
+        self, field_name: str, valid_fields: dict[str, FieldInfo]
+    ) -> None:
+        if field_name not in valid_fields:
+            raise InvalidFilterError(field_name)
+
+    def _handle_equality(
+        self, field_name: str, value: FilterValue, operator: str
+    ) -> None:
+        if value is None:
+            self.filters.append((f"{field_name} IS NULL", None, "__isnull"))
+        else:
+            self.filters.append((field_name, value, operator))
+
+    def _handle_null(
+        self, field_name: str, _: FilterValue, operator: str
+    ) -> None:
+        condition = (
+            f"{field_name} IS NOT NULL"
+            if operator == "__notnull"
+            else f"{field_name} IS NULL"
+        )
+        self.filters.append((condition, None, operator))
+
+    def _handle_in(
+        self, field_name: str, value: FilterValue, operator: str
+    ) -> None:
+        if not isinstance(value, list):
+            err = f"{field_name} requires a list for '{operator}'"
+            raise TypeError(err)
+        sql_operator = OPERATOR_MAPPING.get(operator, "IN")
+        placeholder_list = ", ".join(["?"] * len(value))
+        self.filters.append(
+            (
+                f"{field_name} {sql_operator} ({placeholder_list})",
+                value,
+                operator,
+            )
+        )
+
+    def _handle_like(
+        self, field_name: str, value: FilterValue, operator: str
+    ) -> None:
+        if not isinstance(value, str):
+            err = f"{field_name} requires a string value for '{operator}'"
+            raise TypeError(err)
+        formatted_value = self._format_string_for_operator(operator, value)
+        if operator in ["__startswith", "__endswith", "__contains"]:
+            self.filters.append(
+                (
+                    f"{field_name} GLOB ?",
+                    [formatted_value],
+                    operator,
+                )
+            )
+        elif operator in ["__istartswith", "__iendswith", "__icontains"]:
+            self.filters.append(
+                (
+                    f"{field_name} LIKE ?",
+                    [formatted_value],
+                    operator,
+                )
+            )
+
+    def _handle_comparison(
+        self, field_name: str, value: FilterValue, operator: str
+    ) -> None:
+        sql_operator = OPERATOR_MAPPING[operator]
+        self.filters.append((f"{field_name} {sql_operator} ?", value, operator))
+
+    # Helper method for parsing field and operator
+    def _parse_field_operator(self, field: str) -> tuple[str, str]:
+        for operator in OPERATOR_MAPPING:
+            if field.endswith(operator):
+                return field[: -len(operator)], operator
+        return field, "__eq"  # Default to equality if no operator is found
+
+    # Helper method for formatting string operators (like startswith)
+    def _format_string_for_operator(self, operator: str, value: str) -> str:
+        # Mapping operators to their corresponding string format
+        format_map = {
+            "__startswith": f"{value}*",
+            "__endswith": f"*{value}",
+            "__contains": f"*{value}*",
+            "__istartswith": f"{value.lower()}%",
+            "__iendswith": f"%{value.lower()}",
+            "__icontains": f"%{value.lower()}%",
+        }
+
+        # Return the formatted string or the original value if no match
+        return format_map.get(operator, value)
+
     def limit(self, limit_value: int) -> Self:
         """Limit the number of results returned by the query."""
         self._limit = limit_value
@@ -49,7 +174,7 @@ class QueryBuilder:
 
     def offset(self, offset_value: int) -> Self:
         """Set an offset value for the query."""
-        if offset_value <= 0:
+        if offset_value < 0:
             raise InvalidOffsetError(offset_value)
         self._offset = offset_value
 
@@ -57,28 +182,51 @@ class QueryBuilder:
             self._limit = -1
         return self
 
-    def order(self, order_by_field: str) -> Self:
-        """Order the results by a specific field and optionally direction."""
-        self._order_by = order_by_field
+    def order(self, order_by_field: str, direction: str = "ASC") -> Self:
+        """Order the results by a specific field and optionally direction.
+
+        Currently only supports ordering by a single field, though this will be
+        expanded in the future. You can chain this method to order by multiple
+        fields.
+
+        Parameters:
+            order_by_field (str): The field to order by.
+            direction (str, optional): The sorting direction, either 'ASC' or
+                'DESC'. Defaults to 'ASC'.
+
+        Returns:
+            Self: Returns the query object for chaining.
+
+        Raises:
+            InvalidOrderError: If the field or direction is invalid.
+        """
+        if order_by_field not in self.model_class.model_fields:
+            err = f"'{order_by_field}' does not exist in the model fields."
+            raise InvalidOrderError(err)
+
+        valid_directions = {"ASC", "DESC"}
+        if direction.upper() not in valid_directions:
+            err = f"'{direction}' is not a valid sorting direction."
+            raise InvalidOrderError(err)
+
+        self._order_by = f'"{order_by_field}" {direction.upper()}'
         return self
 
     def _execute_query(
         self,
         *,
         fetch_one: bool = False,
+        count_only: bool = False,
     ) -> list[tuple[Any, ...]] | Optional[tuple[Any, ...]]:
         """Helper function to execute the query with filters."""
         fields = ", ".join(self.model_class.model_fields)
 
         # Build the WHERE clause with special handling for None (NULL in SQL)
-        where_clause = " AND ".join(
-            [
-                f"{field} IS NULL" if value is None else f"{field} = ?"
-                for field, value in self.filters
-            ]
-        )
+        values, where_clause = self._parse_filter()
 
-        sql = f"SELECT {fields} FROM {self.table_name}"  # noqa: S608
+        select_fields = fields if not count_only else "COUNT(*)"
+
+        sql = f'SELECT {select_fields} FROM "{self.table_name}"'  # noqa: S608 # nosec
 
         if self.filters:
             sql += f" WHERE {where_clause}"
@@ -87,13 +235,12 @@ class QueryBuilder:
             sql += f" ORDER BY {self._order_by}"
 
         if self._limit is not None:
-            sql += f" LIMIT {self._limit}"
+            sql += " LIMIT ?"
+            values.append(self._limit)
 
         if self._offset is not None:
-            sql += f" OFFSET {self._offset}"
-
-        # Only include non-None values in the values list
-        values = [value for _, value in self.filters if value is not None]
+            sql += " OFFSET ?"
+            values.append(self._offset)
 
         try:
             with self.db.connect() as conn:
@@ -103,6 +250,25 @@ class QueryBuilder:
         except sqlite3.Error as exc:
             raise RecordFetchError(self.table_name) from exc
 
+    def _parse_filter(self) -> tuple[list[Any], LiteralString]:
+        """Actually parse the filters."""
+        where_clauses = []
+        values = []
+        for field, value, operator in self.filters:
+            if operator == "__eq":
+                where_clauses.append(f"{field} = ?")
+                values.append(value)
+            else:
+                where_clauses.append(field)
+                if operator not in ["__isnull", "__notnull"]:
+                    if isinstance(value, list):
+                        values.extend(value)
+                    else:
+                        values.append(value)
+
+        where_clause = " AND ".join(where_clauses)
+        return values, where_clause
+
     def fetch_all(self) -> list[BaseDBModel]:
         """Fetch all results matching the filters."""
         results = self._execute_query()
@@ -161,22 +327,9 @@ class QueryBuilder:
 
     def count(self) -> int:
         """Return the count of records matching the filters."""
-        where_clause = " AND ".join(
-            [f"{field} = ?" for field, _ in self.filters]
-        )
-        sql = f"SELECT COUNT(*) FROM {self.table_name}"  # noqa: S608
-
-        if self.filters:
-            sql += f" WHERE {where_clause}"
-
-        values = [value for _, value in self.filters]
-
-        with self.db.connect() as conn:
-            cursor = conn.cursor()
-            cursor.execute(sql, values)
-            result = cursor.fetchone()
+        result = self._execute_query(count_only=True)
 
-        return int(result[0]) if result else 0
+        return int(result[0][0]) if result else 0
 
     def exists(self) -> bool:
         """Return True if any record matches the filters."""

sqliter/sqliter.py

@@ -27,7 +27,7 @@ if TYPE_CHECKING:  # pragma: no cover
 class SqliterDB:
     """Class to manage SQLite database interactions."""
 
-    def __init__(self, db_filename: str, *, auto_commit: bool = False) -> None:
+    def __init__(self, db_filename: str, *, auto_commit: bool = True) -> None:
         """Initialize the class and options."""
         self.db_filename = db_filename
         self.auto_commit = auto_commit
@@ -42,6 +42,18 @@ class SqliterDB:
                 raise DatabaseConnectionError(self.db_filename) from exc
         return self.conn
 
+    def close(self) -> None:
+        """Close the connection to the SQLite database."""
+        if self.conn:
+            self._maybe_commit()
+            self.conn.close()
+            self.conn = None
+
+    def commit(self) -> None:
+        """Commit any pending transactions."""
+        if self.conn:
+            self.conn.commit()
+
     def create_table(self, model_class: type[BaseDBModel]) -> None:
         """Create a table based on the Pydantic model."""
         table_name = model_class.get_table_name()
@@ -75,10 +87,10 @@ class SqliterDB:
         except sqlite3.Error as exc:
             raise TableCreationError(table_name) from exc
 
-    def _maybe_commit(self, conn: sqlite3.Connection) -> None:
+    def _maybe_commit(self) -> None:
         """Commit changes if auto_commit is True."""
-        if self.auto_commit:
-            conn.commit()
+        if self.auto_commit and self.conn:
+            self.conn.commit()
 
     def insert(self, model_instance: BaseDBModel) -> None:
         """Insert a new record into the table defined by the Pydantic model."""
@@ -100,7 +112,7 @@ class SqliterDB:
             with self.connect() as conn:
                 cursor = conn.cursor()
                 cursor.execute(insert_sql, values)
-                self._maybe_commit(conn)
+                self._maybe_commit()
         except sqlite3.Error as exc:
             raise RecordInsertionError(table_name) from exc
 
@@ -167,7 +179,7 @@ class SqliterDB:
                 if cursor.rowcount == 0:
                     raise RecordNotFoundError(primary_key_value)
 
-                self._maybe_commit(conn)
+                self._maybe_commit()
 
         except sqlite3.Error as exc:
             raise RecordUpdateError(table_name) from exc
@@ -190,7 +202,7 @@ class SqliterDB:
 
                 if cursor.rowcount == 0:
                     raise RecordNotFoundError(primary_key_value)
-                self._maybe_commit(conn)
+                self._maybe_commit()
         except sqlite3.Error as exc:
             raise RecordDeletionError(table_name) from exc
 
@@ -216,7 +228,8 @@ class SqliterDB:
                 if exc_type:
                     # Roll back the transaction if there was an exception
                     self.conn.rollback()
-                self._maybe_commit(self.conn)
+                else:
+                    self.conn.commit()
             finally:
                 # Close the connection and reset the instance variable
                 self.conn.close()

sqliter_py-0.2.0.dist-info/METADATA

@@ -0,0 +1,351 @@
+Metadata-Version: 2.3
+Name: sqliter-py
+Version: 0.2.0
+Summary: Interact with SQLite databases using Python and Pydantic
+Project-URL: Pull Requests, https://github.com/seapagan/sqliter-py/pulls
+Project-URL: Bug Tracker, https://github.com/seapagan/sqliter-py/issues
+Project-URL: Changelog, https://github.com/seapagan/sqliter-py/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/seapagan/sqliter-py
+Author-email: Grant Ramsay <grant@gnramsay.com>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+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.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: pydantic>=2.9.0
+Description-Content-Type: text/markdown
+
+# SQLiter <!-- omit in toc -->
+
+![PyPI - Version](https://img.shields.io/pypi/v/sqliter-py)
+[![Test Suite](https://github.com/seapagan/sqliter-py/actions/workflows/testing.yml/badge.svg)](https://github.com/seapagan/sqliter-py/actions/workflows/testing.yml)
+[![Linting](https://github.com/seapagan/sqliter-py/actions/workflows/linting.yml/badge.svg)](https://github.com/seapagan/sqliter-py/actions/workflows/linting.yml)
+[![Type Checking](https://github.com/seapagan/sqliter-py/actions/workflows/mypy.yml/badge.svg)](https://github.com/seapagan/sqliter-py/actions/workflows/mypy.yml)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sqliter-py)
+
+SQLiter is a lightweight Object-Relational Mapping (ORM) library for SQLite
+databases in Python. It provides a simplified interface for interacting with
+SQLite databases using Pydantic models. The only external run-time dependency
+is Pydantic itself.
+
+It does not aim to be a full-fledged ORM like SQLAlchemy, but rather a simple
+and easy-to-use library for basic database operations, especially for small
+projects. It is NOT asynchronous and does not support complex queries (at this
+time).
+
+The ideal use case is more for Python CLI tools that need to store data in a
+database-like format without needing to learn SQL or use a full ORM.
+
+> [!NOTE]
+> This project is still in the early stages of development and is lacking some
+> planned functionality. Please use with caution.
+>
+> See the [TODO](TODO.md) for planned features and improvements.
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Detailed Usage](#detailed-usage)
+  - [Defining Models](#defining-models)
+  - [Database Operations](#database-operations)
+    - [Creating a Connection](#creating-a-connection)
+    - [Creating Tables](#creating-tables)
+    - [Inserting Records](#inserting-records)
+    - [Querying Records](#querying-records)
+    - [Updating Records](#updating-records)
+    - [Deleting Records](#deleting-records)
+    - [Commit your changes](#commit-your-changes)
+    - [Close the Connection](#close-the-connection)
+  - [Transactions](#transactions)
+  - [Filter Options](#filter-options)
+    - [Basic Filters](#basic-filters)
+    - [Null Checks](#null-checks)
+    - [Comparison Operators](#comparison-operators)
+    - [List Operations](#list-operations)
+    - [String Operations (Case-Sensitive)](#string-operations-case-sensitive)
+    - [String Operations (Case-Insensitive)](#string-operations-case-insensitive)
+- [Contributing](#contributing)
+- [License](#license)
+- [Acknowledgements](#acknowledgements)
+
+## Features
+
+- Table creation based on Pydantic models
+- CRUD operations (Create, Read, Update, Delete)
+- Basic query building with filtering, ordering, and pagination
+- Transaction support
+- Custom exceptions for better error handling
+
+## Installation
+
+You can install SQLiter using whichever method you prefer or is compatible with
+your project setup.
+
+With `pip`:
+
+```bash
+pip install sqliter-py
+```
+
+Or `Poetry`:
+
+```bash
+poetry add sqliter-py
+```
+
+Or `uv` which is rapidly becoming my favorite tool for managing projects and
+virtual environments (`uv` is used for developing this project and in the CI):
+
+```bash
+uv add sqliter-py
+```
+
+## Quick Start
+
+Here's a quick example of how to use SQLiter:
+
+```python
+from sqliter import SqliterDB
+from sqliter.model import BaseDBModel
+
+# Define your model
+class User(BaseDBModel):
+    name: str
+    age: int
+
+    class Meta:
+        table_name = "users"
+
+# Create a database connection
+db = SqliterDB("example.db")
+
+# Create the table
+db.create_table(User)
+
+# Insert a record
+user = User(name="John Doe", age=30)
+db.insert(user)
+
+# Query records
+results = db.select(User).filter(name="John Doe").fetch_all()
+for user in results:
+    print(f"User: {user.name}, Age: {user.age}")
+
+# Update a record
+user.age = 31
+db.update(user)
+
+# Delete a record
+db.delete(User, "John Doe")
+```
+
+## Detailed Usage
+
+### Defining Models
+
+Models in SQLiter are based on Pydantic's `BaseModel`. You can define your
+models like this:
+
+```python
+from sqliter.model import BaseDBModel
+
+class User(BaseDBModel):
+    name: str
+    age: int
+    email: str
+
+    class Meta:
+        table_name = "users"
+        primary_key = "name"  # Default is "id"
+        create_id = False  # Set to True to auto-create an ID field
+```
+
+### Database Operations
+
+#### Creating a Connection
+
+```python
+from sqliter import SqliterDB
+
+db = SqliterDB("your_database.db")
+```
+
+The default behavior is to automatically commit changes to the database after
+each operation. If you want to disable this behavior, you can set `auto_commit=False`
+when creating the database connection:
+
+```python
+db = SqliterDB("your_database.db", auto_commit=False)
+```
+
+It is then up to you to manually commit changes using the `commit()` method.
+This can be useful when you want to perform multiple operations in a single
+transaction without the overhead of committing after each operation.
+
+#### Creating Tables
+
+```python
+db.create_table(User)
+```
+
+#### Inserting Records
+
+```python
+user = User(name="Jane Doe", age=25, email="jane@example.com")
+db.insert(user)
+```
+
+#### Querying Records
+
+```python
+# Fetch all users
+all_users = db.select(User).fetch_all()
+
+# Filter users
+young_users = db.select(User).filter(age=25).fetch_all()
+
+# Order users
+ordered_users = db.select(User).order("age", direction="DESC").fetch_all()
+
+# Limit and offset
+paginated_users = db.select(User).limit(10).offset(20).fetch_all()
+```
+
+See below for more advanced filtering options.
+
+#### Updating Records
+
+```python
+user.age = 26
+db.update(user)
+```
+
+#### Deleting Records
+
+```python
+db.delete(User, "Jane Doe")
+```
+
+#### Commit your changes
+
+By default, SQLiter will automatically commit changes to the database after each
+operation. If you want to disable this behavior, you can set `auto_commit=False`
+when creating the database connection:
+
+```python
+db = SqliterDB("your_database.db", auto_commit=False)
+```
+
+You can then manually commit changes using the `commit()` method:
+
+```python
+db.commit()
+```
+
+#### Close the Connection
+
+When you're done with the database connection, you should close it to release
+resources:
+
+```python
+db.close()
+```
+
+Note that closing the connection will also commit any pending changes, unless
+`auto_commit` is set to `False`.
+
+### Transactions
+
+SQLiter supports transactions using Python's context manager:
+
+```python
+with db:
+    db.insert(User(name="Alice", age=30, email="alice@example.com"))
+    db.insert(User(name="Bob", age=35, email="bob@example.com"))
+    # If an exception occurs, the transaction will be rolled back
+```
+
+> [!WARNING]
+> Using the context manager will automatically commit the transaction
+> at the end (unless an exception occurs), regardless of the `auto_commit`
+> setting.
+>
+> the 'close()' method will also be called when the context manager exits, so you
+> do not need to call it manually.
+
+### Filter Options
+
+The `filter()` method in SQLiter supports various filter options to query records.
+
+#### Basic Filters
+
+- `__eq`: Equal to (default if no operator is specified)
+  - Example: `name="John"` or `name__eq="John"`
+
+#### Null Checks
+
+- `__isnull`: Is NULL
+  - Example: `email__isnull=True`
+- `__notnull`: Is NOT NULL
+  - Example: `email__notnull=True`
+
+#### Comparison Operators
+
+- `__lt`: Less than
+  - Example: `age__lt=30`
+- `__lte`: Less than or equal to
+  - Example: `age__lte=30`
+- `__gt`: Greater than
+  - Example: `age__gt=30`
+- `__gte`: Greater than or equal to
+  - Example: `age__gte=30`
+- `__ne`: Not equal to
+  - Example: `status__ne="inactive"`
+
+#### List Operations
+
+- `__in`: In a list of values
+  - Example: `status__in=["active", "pending"]`
+- `__not_in`: Not in a list of values
+  - Example: `category__not_in=["archived", "deleted"]`
+
+#### String Operations (Case-Sensitive)
+
+- `__startswith`: Starts with
+  - Example: `name__startswith="A"`
+- `__endswith`: Ends with
+  - Example: `email__endswith=".com"`
+- `__contains`: Contains
+  - Example: `description__contains="important"`
+
+#### String Operations (Case-Insensitive)
+
+- `__istartswith`: Starts with (case-insensitive)
+  - Example: `name__istartswith="a"`
+- `__iendswith`: Ends with (case-insensitive)
+  - Example: `email__iendswith=".COM"`
+- `__icontains`: Contains (case-insensitive)
+  - Example: `description__icontains="IMPORTANT"`
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License.
+
+## Acknowledgements
+
+SQLiter was initially developed as an experiment to see how helpful ChatGPT and
+Claud AI can be to speed up the development process. The initial version of the
+code was generated by ChatGPT, with subsequent manual/AI refinements and
+improvements.

sqliter_py-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+sqliter/__init__.py,sha256=L8R0uvCbbbACwaI5xtd3khtvpNhlPRgHJAaYZvqjzig,134
+sqliter/constants.py,sha256=QEUC6kPkwYItgFRUmV6qfK9YV1PcUyUoBwj34yhAyik,441
+sqliter/exceptions.py,sha256=RP1T67PkJMOgkT7yIjES1xil832_UmuAeABtNiv-RKE,3756
+sqliter/sqliter.py,sha256=1MOa763OQdwkiAHHAitEKox5O9EV0FVMbMWC7pqyk9U,7823
+sqliter/model/__init__.py,sha256=Ovpkbyx2-T6Oee0qFNgUBBc2M0uwK-cdG0pigG3mkd8,179
+sqliter/model/model.py,sha256=t1w38om37gma1gRk01Z_9II0h4g-l734ijN_8M1SYoY,1247
+sqliter/query/__init__.py,sha256=BluNMJpuoo2PsYN-bL7fXlEc02O_8LgOMsvCmyv04ao,125
+sqliter/query/query.py,sha256=dRW-Y7X3qH4HrTw-oFbomnl4Kz7WOsImIfoKXZqkMKQ,11648
+sqliter_py-0.2.0.dist-info/METADATA,sha256=OBYavQg-H3HipYh_mVkaJ4cL_EUpzqPk1MtypWUpwlg,9880
+sqliter_py-0.2.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+sqliter_py-0.2.0.dist-info/RECORD,,

sqliter_py-0.1.1.dist-info/METADATA

@@ -1,204 +0,0 @@
-Metadata-Version: 2.3
-Name: sqliter-py
-Version: 0.1.1
-Summary: Interact with SQLite databases using Python and Pydantic
-Project-URL: Pull Requests, https://github.com/seapagan/sqliter-py/pulls
-Project-URL: Bug Tracker, https://github.com/seapagan/sqliter-py/issues
-Project-URL: Repository, https://github.com/seapagan/sqliter-py
-Author-email: Grant Ramsay <grant@gnramsay.com>
-License-Expression: MIT
-Classifier: Development Status :: 4 - Beta
-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.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Software Development
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
-Requires-Dist: pydantic>=2.9.0
-Description-Content-Type: text/markdown
-
-# SQLiter
-
-<!-- ![PyPI - Version](https://img.shields.io/pypi/v/sqliter-py) -->
-[![Test Suite](https://github.com/seapagan/sqliter-py/actions/workflows/testing.yml/badge.svg)](https://github.com/seapagan/sqliter-py/actions/workflows/testing.yml)
-[![Linting](https://github.com/seapagan/sqliter-py/actions/workflows/linting.yml/badge.svg)](https://github.com/seapagan/sqliter-py/actions/workflows/linting.yml)
-[![Type Checking](https://github.com/seapagan/sqliter-py/actions/workflows/mypy.yml/badge.svg)](https://github.com/seapagan/sqliter-py/actions/workflows/mypy.yml)
-<!-- ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sqliter-py) -->
-
-SQLiter is a lightweight Object-Relational Mapping (ORM) library for SQLite
-databases in Python. It provides a simplified interface for interacting with
-SQLite databases using Pydantic models.
-
-It does not aim to be a full-fledged ORM like SQLAlchemy, but rather a simple
-and easy-to-use library for basic database operations, especially for small
-projects. It is NOT asynchronous and does not support complex queries (at this
-time).
-
-The ideal use case is more for Python CLI tools that need to store data in a
-database-like format without needing to learn SQL or use a full ORM.
-
-> [!NOTE]
-> This project is still in the early stages of development and is lacking some
-> planned functionality. Please use with caution.
->
-> See the [TODO](TODO.md) for planned features and improvements.
-
-## Features
-
-- Table creation based on Pydantic models
-- CRUD operations (Create, Read, Update, Delete)
-- Basic query building with filtering, ordering, and pagination
-- Transaction support
-- Custom exceptions for better error handling
-
-## Installation
-
-You can install SQLiter using pip:
-
-```bash
-pip install sqliter-py
-```
-
-## Quick Start
-
-Here's a quick example of how to use SQLiter:
-
-```python
-from sqliter import SqliterDB
-from sqliter.model import BaseDBModel
-
-# Define your model
-class User(BaseDBModel):
-    name: str
-    age: int
-
-    class Meta:
-        table_name = "users"
-
-# Create a database connection
-db = SqliterDB("example.db", auto_commit=True)
-
-# Create the table
-db.create_table(User)
-
-# Insert a record
-user = User(name="John Doe", age=30)
-db.insert(user)
-
-# Query records
-results = db.select(User).filter(name="John Doe").fetch_all()
-for user in results:
-    print(f"User: {user.name}, Age: {user.age}")
-
-# Update a record
-user.age = 31
-db.update(user)
-
-# Delete a record
-db.delete(User, "John Doe")
-```
-
-## Detailed Usage
-
-### Defining Models
-
-Models in SQLiter are based on Pydantic's `BaseModel`. You can define your
-models like this:
-
-```python
-from sqliter.model import BaseDBModel
-
-class User(BaseDBModel):
-    name: str
-    age: int
-    email: str
-
-    class Meta:
-        table_name = "users"
-        primary_key = "name"  # Default is "id"
-        create_id = False  # Set to True to auto-create an ID field
-```
-
-### Database Operations
-
-#### Creating a Connection
-
-```python
-from sqliter import SqliterDB
-
-db = SqliterDB("your_database.db", auto_commit=True)
-```
-
-#### Creating Tables
-
-```python
-db.create_table(User)
-```
-
-#### Inserting Records
-
-```python
-user = User(name="Jane Doe", age=25, email="jane@example.com")
-db.insert(user)
-```
-
-#### Querying Records
-
-```python
-# Fetch all users
-all_users = db.select(User).fetch_all()
-
-# Filter users
-young_users = db.select(User).filter(age=25).fetch_all()
-
-# Order users
-ordered_users = db.select(User).order("age DESC").fetch_all()
-
-# Limit and offset
-paginated_users = db.select(User).limit(10).offset(20).fetch_all()
-```
-
-Note: The filtering in SQLiter is basic and supports exact matches. Complex
-queries like `age__lt` are not supported in the current implementation.
-
-#### Updating Records
-
-```python
-user.age = 26
-db.update(user)
-```
-
-#### Deleting Records
-
-```python
-db.delete(User, "Jane Doe")
-```
-
-### Transactions
-
-SQLiter supports transactions using Python's context manager:
-
-```python
-with db:
-    db.insert(User(name="Alice", age=30, email="alice@example.com"))
-    db.insert(User(name="Bob", age=35, email="bob@example.com"))
-    # If an exception occurs, the transaction will be rolled back
-```
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## License
-
-This project is licensed under the MIT License.
-
-## Acknowledgements
-
-SQLiter was initially developed as an experiment using ChatGPT, with subsequent
-manual refinements and improvements.

sqliter_py-0.1.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-sqliter/__init__.py,sha256=L8R0uvCbbbACwaI5xtd3khtvpNhlPRgHJAaYZvqjzig,134
-sqliter/exceptions.py,sha256=5NO9DwHMVKrDZP908G63J5-ANBJDCwbBkXL7h_Bit2Q,3610
-sqliter/sqliter.py,sha256=R69oNusPEg0Q_zRPFetS9VUUCT5pjatXnUr3Tv6yzjE,7494
-sqliter/model/__init__.py,sha256=Ovpkbyx2-T6Oee0qFNgUBBc2M0uwK-cdG0pigG3mkd8,179
-sqliter/model/model.py,sha256=t1w38om37gma1gRk01Z_9II0h4g-l734ijN_8M1SYoY,1247
-sqliter/query/__init__.py,sha256=BluNMJpuoo2PsYN-bL7fXlEc02O_8LgOMsvCmyv04ao,125
-sqliter/query/query.py,sha256=BRKCdMBOlbcIU5CUxRyKBF4aFT2AboUPu7UwbJ1s5hs,5793
-sqliter_py-0.1.1.dist-info/METADATA,sha256=ehe8KZXc08ftvn2i6FGiw3Qe8jK6QsqApDoDQm9p0XE,5477
-sqliter_py-0.1.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-sqliter_py-0.1.1.dist-info/RECORD,,