sqlite7 1.0.0__py3-none-any.whl

sqlite7/exc.py

@@ -0,0 +1,101 @@
+"""Package-specific exceptions for sqlite7.
+
+This module mirrors the familiar DB-API exception hierarchy for the native SQLite backend.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(slots=True)
+class SQLiteErrorDetails:
+    """Extra metadata captured from a native SQLite failure.
+
+    Attributes:
+        errorcode: SQLite numeric error code, when available.
+        errorname: SQLite symbolic error name, when available.
+    """
+
+    errorcode: Optional[int] = None
+    errorname: Optional[str] = None
+
+
+class SQLite7Error(Exception):
+    """Base exception for all package-defined errors.
+
+    Args:
+        message: Human-readable error message.
+        original: Original backend exception, when present.
+        details: Structured SQLite metadata, when present.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        original: BaseException | None = None,
+        details: SQLiteErrorDetails | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.original = original
+        self.details = details or SQLiteErrorDetails()
+        self.sqlite_errorcode = self.details.errorcode
+        self.sqlite_errorname = self.details.errorname
+
+
+class Warning(SQLite7Error):
+    """Raised for important non-fatal conditions."""
+
+
+class Error(SQLite7Error):
+    """Base class for database-related errors."""
+
+
+class InterfaceError(Error):
+    """Raised for interface misuse or invalid inputs."""
+
+
+class DatabaseError(Error):
+    """Raised for general database failures."""
+
+
+class DataError(DatabaseError):
+    """Raised for data processing failures."""
+
+
+class OperationalError(DatabaseError):
+    """Raised for operational failures such as locks or path issues."""
+
+
+class IntegrityError(DatabaseError):
+    """Raised for constraint violations."""
+
+
+class InternalError(DatabaseError):
+    """Raised when SQLite reports an internal failure."""
+
+
+class ProgrammingError(DatabaseError):
+    """Raised for invalid SQL or programming mistakes."""
+
+
+class NotSupportedError(DatabaseError):
+    """Raised for unsupported SQLite features."""
+
+
+class ConfigurationError(InterfaceError):
+    """Raised for invalid client configuration."""
+
+
+class ValidationError(InterfaceError):
+    """Raised when helper-method inputs are malformed."""
+
+
+class InvalidIdentifierError(ValidationError):
+    """Raised when a SQL identifier fails safety validation."""
+
+
+class ConnectionClosedError(InterfaceError):
+    """Raised when an operation is attempted on a closed connection."""

sqlite7/helpers.py

@@ -0,0 +1,77 @@
+"""Internal helper utilities for sqlite7."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Any
+
+from . import exc
+
+_IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def validate_identifier(value: str, *, kind: str = "identifier") -> str:
+    if not isinstance(value, str):
+        raise exc.InvalidIdentifierError(f"{kind} must be a string")
+    if not value:
+        raise exc.InvalidIdentifierError(f"{kind} must not be empty")
+    if not _IDENTIFIER_RE.fullmatch(value):
+        raise exc.InvalidIdentifierError(
+            f"Invalid {kind}: {value!r}. Only letters, numbers, and underscores are allowed, and it must not start with a number."
+        )
+    return value
+
+
+def quote_identifier(value: str) -> str:
+    return f'"{validate_identifier(value)}"'
+
+
+def normalize_params(params: Sequence[Any] | None) -> Sequence[Any]:
+    if params is None:
+        return ()
+    if isinstance(params, Mapping):
+        raise exc.ValidationError(
+            "Named SQL parameters are no longer supported. Use positional parameters with ? placeholders instead."
+        )
+    return params
+
+
+def ensure_mapping_row(row: Any, *, index: int) -> Mapping[str, Any]:
+    if not isinstance(row, Mapping):
+        raise exc.ValidationError(
+            f"rows[{index}] must be a mapping of column names to values; got {type(row).__name__}"
+        )
+    if not row:
+        raise exc.ValidationError(f"rows[{index}] must not be empty")
+    for key in row.keys():
+        validate_identifier(str(key), kind="column name")
+    return row
+
+
+def ensure_consistent_rows(rows: Iterable[Mapping[str, Any]]) -> list[Mapping[str, Any]]:
+    materialized = [ensure_mapping_row(row, index=index) for index, row in enumerate(rows)]
+    if not materialized:
+        raise exc.ValidationError("rows must contain at least one item")
+    first_keys = list(materialized[0].keys())
+    for index, row in enumerate(materialized[1:], start=1):
+        row_keys = list(row.keys())
+        if row_keys != first_keys:
+            raise exc.ValidationError(
+                f"rows[{index}] has different keys. Expected {first_keys!r}, got {row_keys!r}"
+            )
+    return materialized
+
+
+def build_assignment_list(columns: Sequence[str]) -> str:
+    return ", ".join(f"{quote_identifier(column)} = ?" for column in columns)
+
+
+def build_placeholders(count: int) -> str:
+    return ", ".join("?" for _ in range(count))
+
+
+def map_sqlite_exception(error: BaseException) -> exc.Error:
+    if isinstance(error, exc.Error):
+        return error
+    return exc.Error(str(error), original=error)

sqlite7/result.py

@@ -0,0 +1,22 @@
+"""Result primitives for sqlite7."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True, frozen=True)
+class StatementResult:
+    """Structured metadata about a write statement.
+
+    Attributes:
+        rowcount: Number of affected rows reported by SQLite.
+        lastrowid: Last inserted row id, when available.
+    """
+
+    rowcount: int
+    lastrowid: int | None = None
+
+
+RowDict = dict[str, Any]

sqlite7/transaction.py

@@ -0,0 +1,23 @@
+"""Transaction context manager for the synchronous sqlite7 client."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .database import Database
+
+
+@dataclass(slots=True)
+class Transaction:
+    """Synchronous transaction context manager with savepoint nesting support."""
+
+    database: "Database"
+
+    def __enter__(self) -> "Database":
+        self.database._enter_transaction()
+        return self.database
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.database._exit_transaction(exc is None)

sqlite7-1.0.0.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: sqlite7
+Version: 1.0.0
+Summary: A DB-API 2.0 style interface for SQLite databases.
+Home-page: https://github.com/joumaico/sqlite7
+Author: Joumaico Maulas
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# SQLite7
+
+SQLite7 is a DB-API 2.0 style interface for SQLite databases backed directly by the SQLite C library, with both synchronous and asynchronous APIs.
+
+## Installation
+
+```bash
+pip install sqlite7
+```
+
+**Requires:** Python 3.11+
+
+## Quick Example
+
+```python
+from sqlite7 import connect
+
+with open_db(":memory:") as db:
+    db.script(
+        '''
+        CREATE TABLE users (
+            id INTEGER PRIMARY KEY,
+            email TEXT UNIQUE NOT NULL,
+            name TEXT NOT NULL,
+            age INTEGER NOT NULL
+        );
+        '''
+    )
+
+    users = db.table("users")
+    users.insert({"email": "ada@example.com", "name": "Ada", "age": 36})
+    users.insert({"email": "grace@example.com", "name": "Grace", "age": 37})
+
+    rows = users.select(
+        columns=["id", "name"],
+        where="age >= ?",
+        params=[36],
+        order_by="id ASC",
+        limit=10,
+        offset=0,
+    )
+    print(rows)
+```
+
+## License
+
+MIT License

sqlite7-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+sqlite7/__init__.py,sha256=FZwxF7EIuhlExdLhyZ9S4SuF5qP7CIDFMH_wpfSkVJk,1815
+sqlite7/_native.py,sha256=7gfzdWsnVQVC-3VVGwnpuk89BaT0YXCbpcRhFa89yks,17325
+sqlite7/async_database.py,sha256=KobQhvzYY4WXDbDSX5dotTOvAcAV82HnJf400evPCds,11607
+sqlite7/database.py,sha256=XhjrW3aBddKuqzTz0OYzEQsObkxaydwxo4pY1ygPcfo,20979
+sqlite7/dialect.py,sha256=Ss_AbfU-N5BaWxl-UYpvibvEyspWIEQUeSMqgOtGeF4,1052
+sqlite7/exc.py,sha256=kOLbdXa-hHMbIqGzTGJLmdytjWVCuMR5NE3yMDrxIHs,2576
+sqlite7/helpers.py,sha256=dJ_WAzQCjvq2kZ_rz1-1h5i1labSWLYGqPrRdowunUA,2644
+sqlite7/result.py,sha256=sjd2LTysnc99UPXw0UDmazpr985HFLjhc_RRpTVkZps,467
+sqlite7/transaction.py,sha256=C8DCW7WSJSp8Qz6rhg5eMyDhNgkQIBJC9rhSi8eXc6w,597
+sqlite7-1.0.0.dist-info/licenses/LICENSE,sha256=_bXwoDAsoV0I5L_IvcwSFyAIfLndidmTylC_wtGwtlw,1072
+sqlite7-1.0.0.dist-info/METADATA,sha256=P0DBdCHeC0vN_PE-WSUGoQNhA8uohxvMdHYZqa5B7x8,1753
+sqlite7-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sqlite7-1.0.0.dist-info/top_level.txt,sha256=Rq4T-KEoWV8G0XTWI_jao3gzWCFX26FmS3ZUVxm39yU,8
+sqlite7-1.0.0.dist-info/RECORD,,

sqlite7-1.0.0.dist-info/WHEEL

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

sqlite7-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joumaico Maulas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlite7-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlite7