sqliter-py 0.5.0__tar.gz → 0.6.0__tar.gz

{sqliter_py-0.5.0 → sqliter_py-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sqliter-py
-Version: 0.5.0
+Version: 0.6.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
@@ -75,6 +75,9 @@ Website](https://sqliter.grantramsay.dev)
 ## Features
 
 - Table creation based on Pydantic models
+- Automatic primary key generation
+- User defined indexes on any field
+- Set any field as UNIQUE
 - CRUD operations (Create, Read, Update, Delete)
 - Chained Query building with filtering, ordering, and pagination
 - Transaction support
@@ -98,16 +101,16 @@ virtual environments (`uv` is used for developing this project and in the CI):
 uv add sqliter-py
 ```
 
-With `pip`:
+With `Poetry`:
 
 ```bash
-pip install sqliter-py
+poetry add sqliter-py
 ```
 
-Or with `Poetry`:
+Or with `pip`:
 
 ```bash
-poetry add sqliter-py
+pip install sqliter-py
 ```
 
 ### Optional Dependencies
@@ -116,9 +119,9 @@ Currently by default, the only external dependency is Pydantic. However, there
 are some optional dependencies that can be installed to enable additional
 features:
 
-- `inflect`: For pluralizing table names (if not specified). This just offers a
-  more-advanced pluralization than the default method used. In most cases you
-  will not need this.
+- `inflect`: For pluralizing the auto-generated table names (if not explicitly
+  set in the Model) This just offers a more-advanced pluralization than the
+  default method used. In most cases you will not need this.
 
 See [Installing Optional
 Dependencies](https://sqliter.grantramsay.dev/installation#optional-dependencies)

{sqliter_py-0.5.0 → sqliter_py-0.6.0}/README.md

@@ -47,6 +47,9 @@ Website](https://sqliter.grantramsay.dev)
 ## Features
 
 - Table creation based on Pydantic models
+- Automatic primary key generation
+- User defined indexes on any field
+- Set any field as UNIQUE
 - CRUD operations (Create, Read, Update, Delete)
 - Chained Query building with filtering, ordering, and pagination
 - Transaction support
@@ -70,16 +73,16 @@ virtual environments (`uv` is used for developing this project and in the CI):
 uv add sqliter-py
 ```
 
-With `pip`:
+With `Poetry`:
 
 ```bash
-pip install sqliter-py
+poetry add sqliter-py
 ```
 
-Or with `Poetry`:
+Or with `pip`:
 
 ```bash
-poetry add sqliter-py
+pip install sqliter-py
 ```
 
 ### Optional Dependencies
@@ -88,9 +91,9 @@ Currently by default, the only external dependency is Pydantic. However, there
 are some optional dependencies that can be installed to enable additional
 features:
 
-- `inflect`: For pluralizing table names (if not specified). This just offers a
-  more-advanced pluralization than the default method used. In most cases you
-  will not need this.
+- `inflect`: For pluralizing the auto-generated table names (if not explicitly
+  set in the Model) This just offers a more-advanced pluralization than the
+  default method used. In most cases you will not need this.
 
 See [Installing Optional
 Dependencies](https://sqliter.grantramsay.dev/installation#optional-dependencies)

{sqliter_py-0.5.0 → sqliter_py-0.6.0}/pyproject.toml

@@ -3,7 +3,7 @@
 
 [project]
 name = "sqliter-py"
-version = "0.5.0"
+version = "0.6.0"
 description = "Interact with SQLite databases using Python and Pydantic"
 readme = "README.md"
 requires-python = ">=3.9"

{sqliter_py-0.5.0 → sqliter_py-0.6.0}/sqliter/exceptions.py

@@ -145,3 +145,24 @@ class SqlExecutionError(SqliterError):
     """Raised when an SQL execution fails."""
 
     message_template = "Failed to execute SQL: '{}'"
+
+
+class InvalidIndexError(SqliterError):
+    """Exception raised when an invalid index field is specified.
+
+    This error is triggered if one or more fields specified for an index
+    do not exist in the model's fields.
+
+    Attributes:
+        invalid_fields (list[str]): The list of fields that were invalid.
+        model_class (str): The name of the model where the error occurred.
+    """
+
+    message_template = "Invalid fields for indexing in model '{}': {}"
+
+    def __init__(self, invalid_fields: list[str], model_class: str) -> None:
+        """Tidy up the error message by joining the invalid fields."""
+        # Join invalid fields into a comma-separated string
+        invalid_fields_str = ", ".join(invalid_fields)
+        # Pass the formatted message to the parent class
+        super().__init__(model_class, invalid_fields_str)

{sqliter_py-0.5.0 → sqliter_py-0.6.0}/sqliter/model/__init__.py

@@ -1,9 +1,11 @@
 """This module provides the base model class for SQLiter database models.
 
 It exports the BaseDBModel class, which is used to define database
-models in SQLiter applications.
+models in SQLiter applications, and the Unique class, which is used to
+define unique constraints on model fields.
 """
 
 from .model import BaseDBModel
+from .unique import Unique
 
-__all__ = ["BaseDBModel"]
+__all__ = ["BaseDBModel", "Unique"]

{sqliter_py-0.5.0 → sqliter_py-0.6.0}/sqliter/model/model.py

@@ -10,7 +10,16 @@ in SQLiter applications.
 from __future__ import annotations
 
 import re
-from typing import Any, Optional, TypeVar, Union, cast, get_args, get_origin
+from typing import (
+    Any,
+    ClassVar,
+    Optional,
+    TypeVar,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+)
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -41,14 +50,24 @@ class BaseDBModel(BaseModel):
         """Metadata class for configuring database-specific attributes.
 
         Attributes:
-            create_pk (bool): Whether to create a primary key field.
-            primary_key (str): The name of the primary key field.
-            table_name (Optional[str]): The name of the database table.
+            table_name (Optional[str]): The name of the database table. If not
+                specified, the table name will be inferred from the model class
+                name and converted to snake_case.
+            indexes (ClassVar[list[Union[str, tuple[str]]]]): A list of fields
+                or tuples of fields for which regular (non-unique) indexes
+                should be created. Indexes improve query performance on these
+                fields.
+            unique_indexes (ClassVar[list[Union[str, tuple[str]]]]): A list of
+                fields or tuples of fields for which unique indexes should be
+                created. Unique indexes enforce that all values in these fields
+                are distinct across the table.
         """
 
         table_name: Optional[str] = (
             None  # Table name, defaults to class name if not set
         )
+        indexes: ClassVar[list[Union[str, tuple[str]]]] = []
+        unique_indexes: ClassVar[list[Union[str, tuple[str]]]] = []
 
     @classmethod
     def model_validate_partial(cls: type[T], obj: dict[str, Any]) -> T:

sqliter_py-0.6.0/sqliter/model/unique.py

@@ -0,0 +1,19 @@
+"""Define a custom field type for unique constraints in SQLiter."""
+
+from typing import Any
+
+from pydantic.fields import FieldInfo
+
+
+class Unique(FieldInfo):
+    """A custom field type for unique constraints in SQLiter."""
+
+    def __init__(self, default: Any = ..., **kwargs: Any) -> None:  # noqa: ANN401
+        """Initialize a Unique field.
+
+        Args:
+            default: The default value for the field.
+            **kwargs: Additional keyword arguments to pass to FieldInfo.
+        """
+        super().__init__(default=default, **kwargs)
+        self.unique = True

{sqliter_py-0.5.0 → sqliter_py-0.6.0}/sqliter/sqliter.py

@@ -10,12 +10,13 @@ from __future__ import annotations
 
 import logging
 import sqlite3
-from typing import TYPE_CHECKING, Any, Optional, TypeVar
+from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
 from typing_extensions import Self
 
 from sqliter.exceptions import (
     DatabaseConnectionError,
+    InvalidIndexError,
     RecordDeletionError,
     RecordFetchError,
     RecordInsertionError,
@@ -26,6 +27,7 @@ from sqliter.exceptions import (
     TableDeletionError,
 )
 from sqliter.helpers import infer_sqlite_type
+from sqliter.model.unique import Unique
 from sqliter.query.query import QueryBuilder
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -89,6 +91,8 @@ class SqliterDB:
         self.conn: Optional[sqlite3.Connection] = None
         self.reset = reset
 
+        self._in_transaction = False
+
         if self.debug:
             self._setup_logger()
 
@@ -236,7 +240,12 @@ class SqliterDB:
         for field_name, field_info in model_class.model_fields.items():
             if field_name != primary_key:
                 sqlite_type = infer_sqlite_type(field_info.annotation)
-                fields.append(f"{field_name} {sqlite_type}")
+                unique_constraint = (
+                    "UNIQUE" if isinstance(field_info, Unique) else ""
+                )
+                fields.append(
+                    f"{field_name} {sqlite_type} {unique_constraint}".strip()
+                )
 
         create_str = (
             "CREATE TABLE IF NOT EXISTS" if exists_ok else "CREATE TABLE"
@@ -259,6 +268,65 @@ class SqliterDB:
         except sqlite3.Error as exc:
             raise TableCreationError(table_name) from exc
 
+        # Create regular indexes
+        if hasattr(model_class.Meta, "indexes"):
+            self._create_indexes(
+                model_class, model_class.Meta.indexes, unique=False
+            )
+
+        # Create unique indexes
+        if hasattr(model_class.Meta, "unique_indexes"):
+            self._create_indexes(
+                model_class, model_class.Meta.unique_indexes, unique=True
+            )
+
+    def _create_indexes(
+        self,
+        model_class: type[BaseDBModel],
+        indexes: list[Union[str, tuple[str]]],
+        *,
+        unique: bool = False,
+    ) -> None:
+        """Helper method to create regular or unique indexes.
+
+        Args:
+            model_class: The model class defining the table.
+            indexes: List of fields or tuples of fields to create indexes for.
+            unique: If True, creates UNIQUE indexes; otherwise, creates regular
+                indexes.
+
+        Raises:
+            InvalidIndexError: If any fields specified for indexing do not exist
+                in the model.
+        """
+        valid_fields = set(
+            model_class.model_fields.keys()
+        )  # Get valid fields from the model
+
+        for index in indexes:
+            # Handle multiple fields in tuple form
+            fields = list(index) if isinstance(index, tuple) else [index]
+
+            # Check if all fields exist in the model
+            invalid_fields = [
+                field for field in fields if field not in valid_fields
+            ]
+            if invalid_fields:
+                raise InvalidIndexError(invalid_fields, model_class.__name__)
+
+            # Build the SQL string
+            index_name = "_".join(fields)
+            index_postfix = "_unique" if unique else ""
+            index_type = " UNIQUE " if unique else " "
+
+            create_index_sql = (
+                f"CREATE{index_type}INDEX IF NOT EXISTS "
+                f"idx_{model_class.get_table_name()}"
+                f"_{index_name}{index_postfix} "
+                f"ON {model_class.get_table_name()} ({', '.join(fields)})"
+            )
+            self._execute_sql(create_index_sql)
+
     def _execute_sql(self, sql: str) -> None:
         """Execute an SQL statement.
 
@@ -308,7 +376,7 @@ class SqliterDB:
         This method is called after operations that modify the database,
         committing changes only if auto_commit is set to True.
         """
-        if self.auto_commit and self.conn:
+        if not self._in_transaction and self.auto_commit and self.conn:
             self.conn.commit()
 
     def insert(self, model_instance: T) -> T:
@@ -515,6 +583,7 @@ class SqliterDB:
 
         """
         self.connect()
+        self._in_transaction = True
         return self
 
     def __exit__(
@@ -552,3 +621,4 @@ class SqliterDB:
                 # Close the connection and reset the instance variable
                 self.conn.close()
                 self.conn = None
+                self._in_transaction = False