sqliter-py 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

sqliter/constants.py

@@ -6,8 +6,11 @@ operators and data types, which are crucial for translating between
 Pydantic models and SQLite database operations.
 """
 
+import datetime
+
 # A dictionary mapping SQLiter filter operators to their corresponding SQL
 # operators.
+
 OPERATOR_MAPPING = {
     "__lt": "<",
     "__lte": "<=",
@@ -34,4 +37,6 @@ SQLITE_TYPE_MAPPING = {
     str: "TEXT",
     bool: "INTEGER",  # SQLite stores booleans as integers (0 or 1)
     bytes: "BLOB",
+    datetime.datetime: "INTEGER",  # Store as Unix timestamp
+    datetime.date: "INTEGER",  # Store as Unix timestamp
 }

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/helpers.py

@@ -6,6 +6,9 @@ data types. These utilities support the core functionality of model
 to database schema translation.
 """
 
+from __future__ import annotations
+
+import datetime
 from typing import Union
 
 from sqliter.constants import SQLITE_TYPE_MAPPING
@@ -33,3 +36,65 @@ def infer_sqlite_type(field_type: Union[type, None]) -> str:
 
     # Map the simplified type to an SQLite type
     return SQLITE_TYPE_MAPPING.get(field_type, "TEXT")
+
+
+def to_unix_timestamp(value: datetime.date | datetime.datetime) -> int:
+    """Convert datetime or date to a Unix timestamp in UTC.
+
+    Args:
+        value: The datetime or date object to convert.
+
+    Returns:
+        An integer Unix timestamp.
+
+    Raises:
+        TypeError: If the value is not a datetime or date object.
+    """
+    if isinstance(value, datetime.datetime):
+        # If no timezone is provided, assume local time and convert to UTC
+        if value.tzinfo is None:
+            value = value.astimezone()  # Convert to user's local timezone
+        # Convert to UTC before storing
+        value = value.astimezone(datetime.timezone.utc)
+        return int(value.timestamp())
+    if isinstance(value, datetime.date):
+        # Convert date to datetime at midnight in UTC
+        dt = datetime.datetime.combine(
+            value, datetime.time(0, 0), tzinfo=datetime.timezone.utc
+        )
+        return int(dt.timestamp())
+
+    err_msg = "Expected datetime or date object."
+    raise TypeError(err_msg)
+
+
+def from_unix_timestamp(
+    value: int, to_type: type, *, localize: bool = True
+) -> datetime.date | datetime.datetime:
+    """Convert a Unix timestamp to datetime or date, optionally to local time.
+
+    Args:
+        value: The Unix timestamp as an integer.
+        to_type: The expected output type, either datetime or date.
+        localize: If True, convert the datetime to the user's local timezone.
+
+    Returns:
+        The corresponding datetime or date object.
+
+    Raises:
+        TypeError: If to_type is not datetime or date.
+    """
+    if to_type is datetime.datetime:
+        # Convert the Unix timestamp to UTC datetime
+        dt = datetime.datetime.fromtimestamp(value, tz=datetime.timezone.utc)
+        # Convert to local time if requested
+        return dt.astimezone() if localize else dt
+    if to_type is datetime.date:
+        # Convert to UTC datetime first
+        dt = datetime.datetime.fromtimestamp(value, tz=datetime.timezone.utc)
+        # Convert to local time if requested, then return the date part
+        dt_local = dt.astimezone() if localize else dt
+        return dt_local.date()  # Extract the date part
+
+    err_msg = "Expected datetime or date type."
+    raise TypeError(err_msg)

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 .model import BaseDBModel, SerializableField
+from .unique import Unique
 
-__all__ = ["BaseDBModel"]
+__all__ = ["BaseDBModel", "Unique", "SerializableField"]

sqliter/model/model.py

@@ -9,14 +9,31 @@ in SQLiter applications.
 
 from __future__ import annotations
 
+import datetime
 import re
-from typing import Any, Optional, TypeVar, Union, cast, get_args, get_origin
+from typing import (
+    Any,
+    ClassVar,
+    Optional,
+    Protocol,
+    TypeVar,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+)
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from sqliter.helpers import from_unix_timestamp, to_unix_timestamp
+
 T = TypeVar("T", bound="BaseDBModel")
 
 
+class SerializableField(Protocol):
+    """Protocol for fields that can be serialized or deserialized."""
+
+
 class BaseDBModel(BaseModel):
     """Base model class for SQLiter database models.
 
@@ -29,6 +46,14 @@ class BaseDBModel(BaseModel):
     """
 
     pk: int = Field(0, description="The mandatory primary key of the table.")
+    created_at: int = Field(
+        default=0,
+        description="Unix timestamp when the record was created.",
+    )
+    updated_at: int = Field(
+        default=0,
+        description="Unix timestamp when the record was last updated.",
+    )
 
     model_config = ConfigDict(
         extra="ignore",
@@ -41,14 +66,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:
@@ -132,3 +167,50 @@ class BaseDBModel(BaseModel):
     def should_create_pk(cls) -> bool:
         """Returns True since the primary key is always created."""
         return True
+
+    @classmethod
+    def serialize_field(cls, value: SerializableField) -> SerializableField:
+        """Serialize datetime or date fields to Unix timestamp.
+
+        Args:
+            field_name: The name of the field.
+            value: The value of the field.
+
+        Returns:
+            An integer Unix timestamp if the field is a datetime or date.
+        """
+        if isinstance(value, (datetime.datetime, datetime.date)):
+            return to_unix_timestamp(value)
+        return value  # Return value as-is for non-datetime fields
+
+    # Deserialization after fetching from the database
+
+    @classmethod
+    def deserialize_field(
+        cls,
+        field_name: str,
+        value: SerializableField,
+        *,
+        return_local_time: bool,
+    ) -> object:
+        """Deserialize fields from Unix timestamp to datetime or date.
+
+        Args:
+            field_name: The name of the field being deserialized.
+            value: The Unix timestamp value fetched from the database.
+            return_local_time: Flag to control whether the datetime is localized
+                to the user's timezone.
+
+        Returns:
+            A datetime or date object if the field type is datetime or date,
+            otherwise returns the value as-is.
+        """
+        field_type = cls.__annotations__.get(field_name)
+
+        if field_type in (datetime.datetime, datetime.date) and isinstance(
+            value, int
+        ):
+            return from_unix_timestamp(
+                value, field_type, localize=return_local_time
+            )
+        return value  # Return value as-is for non-datetime fields

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/query/query.py

@@ -35,7 +35,7 @@ if TYPE_CHECKING:  # pragma: no cover
     from pydantic.fields import FieldInfo
 
     from sqliter import SqliterDB
-    from sqliter.model import BaseDBModel
+    from sqliter.model import BaseDBModel, SerializableField
 
 # Define a type alias for the possible value types
 FilterValue = Union[
@@ -609,14 +609,32 @@ class QueryBuilder:
             An instance of the model class populated with the row data.
         """
         if self._fields:
-            return self.model_class.model_validate_partial(
-                {field: row[idx] for idx, field in enumerate(self._fields)}
-            )
-        return self.model_class(
-            **{
-                field: row[idx]
-                for idx, field in enumerate(self.model_class.model_fields)
+            data = {
+                field: self._deserialize(field, row[idx])
+                for idx, field in enumerate(self._fields)
             }
+            return self.model_class.model_validate_partial(data)
+
+        data = {
+            field: self._deserialize(field, row[idx])
+            for idx, field in enumerate(self.model_class.model_fields)
+        }
+        return self.model_class(**data)
+
+    def _deserialize(
+        self, field_name: str, value: SerializableField
+    ) -> SerializableField:
+        """Deserialize a field value if needed.
+
+        Args:
+            field_name: Name of the field being deserialized.
+            value: Value from the database.
+
+        Returns:
+            The deserialized value.
+        """
+        return self.model_class.deserialize_field(
+            field_name, value, return_local_time=self.db.return_local_time
         )
 
     @overload

sqliter/sqliter.py

@@ -10,12 +10,14 @@ from __future__ import annotations
 
 import logging
 import sqlite3
-from typing import TYPE_CHECKING, Any, Optional, TypeVar
+import time
+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 +28,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
@@ -49,7 +52,9 @@ class SqliterDB:
         logger (Optional[logging.Logger]): Custom logger for debug output.
     """
 
-    def __init__(
+    MEMORY_DB = ":memory:"
+
+    def __init__(  # noqa: PLR0913
         self,
         db_filename: Optional[str] = None,
         *,
@@ -58,6 +63,7 @@ class SqliterDB:
         debug: bool = False,
         logger: Optional[logging.Logger] = None,
         reset: bool = False,
+        return_local_time: bool = True,
     ) -> None:
         """Initialize a new SqliterDB instance.
 
@@ -69,12 +75,13 @@ class SqliterDB:
             logger: Custom logger for debug output.
             reset: Whether to reset the database on initialization. This will
                 basically drop all existing tables.
+            return_local_time: Whether to return local time for datetime fields.
 
         Raises:
             ValueError: If no filename is provided for a non-memory database.
         """
         if memory:
-            self.db_filename = ":memory:"
+            self.db_filename = self.MEMORY_DB
         elif db_filename:
             self.db_filename = db_filename
         else:
@@ -88,6 +95,9 @@ class SqliterDB:
         self.logger = logger
         self.conn: Optional[sqlite3.Connection] = None
         self.reset = reset
+        self.return_local_time = return_local_time
+
+        self._in_transaction = False
 
         if self.debug:
             self._setup_logger()
@@ -95,6 +105,54 @@ class SqliterDB:
         if self.reset:
             self._reset_database()
 
+    @property
+    def filename(self) -> Optional[str]:
+        """Returns the filename of the current database or None if in-memory."""
+        return None if self.db_filename == self.MEMORY_DB else self.db_filename
+
+    @property
+    def is_memory(self) -> bool:
+        """Returns True if the database is in-memory."""
+        return self.db_filename == self.MEMORY_DB
+
+    @property
+    def is_autocommit(self) -> bool:
+        """Returns True if auto-commit is enabled."""
+        return self.auto_commit
+
+    @property
+    def is_connected(self) -> bool:
+        """Returns True if the database is connected, False otherwise."""
+        return self.conn is not None
+
+    @property
+    def table_names(self) -> list[str]:
+        """Returns a list of all table names in the database.
+
+        Temporarily connects to the database if not connected and restores
+        the connection state afterward.
+        """
+        was_connected = self.is_connected
+        if not was_connected:
+            self.connect()
+
+        if self.conn is None:
+            err_msg = "Failed to establish a database connection."
+            raise DatabaseConnectionError(err_msg)
+
+        cursor = self.conn.cursor()
+        cursor.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' "
+            "AND name NOT LIKE 'sqlite_%';"
+        )
+        tables = [row[0] for row in cursor.fetchall()]
+
+        # Restore the connection state
+        if not was_connected:
+            self.close()
+
+        return tables
+
     def _reset_database(self) -> None:
         """Drop all user-created tables in the database."""
         with self.connect() as conn:
@@ -236,7 +294,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 +322,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,14 +430,21 @@ 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:
+    def insert(
+        self, model_instance: T, *, timestamp_override: bool = False
+    ) -> T:
         """Insert a new record into the database.
 
         Args:
             model_instance: The instance of the model class to insert.
+            timestamp_override: If True, override the created_at and updated_at
+                timestamps with provided values. Default is False. If the values
+                are not provided, they will be set to the current time as
+                normal. Without this flag, the timestamps will always be set to
+                the current time, even if provided.
 
         Returns:
             The updated model instance with the primary key (pk) set.
@@ -326,8 +455,28 @@ class SqliterDB:
         model_class = type(model_instance)
         table_name = model_class.get_table_name()
 
+        # Always set created_at and updated_at timestamps
+        current_timestamp = int(time.time())
+
+        # Handle the case where timestamp_override is False
+        if not timestamp_override:
+            # Always override both timestamps with the current time
+            model_instance.created_at = current_timestamp
+            model_instance.updated_at = current_timestamp
+        else:
+            # Respect provided values, but set to current time if they are 0
+            if model_instance.created_at == 0:
+                model_instance.created_at = current_timestamp
+            if model_instance.updated_at == 0:
+                model_instance.updated_at = current_timestamp
+
         # Get the data from the model
         data = model_instance.model_dump()
+
+        # Serialize the data
+        for field_name, value in list(data.items()):
+            data[field_name] = model_instance.serialize_field(value)
+
         # remove the primary key field if it exists, otherwise we'll get
         # TypeErrors as multiple primary keys will exist
         if data.get("pk", None) == 0:
@@ -405,24 +554,27 @@ class SqliterDB:
 
         Raises:
             RecordUpdateError: If there's an error updating the record or if it
-            is not found.
+                is not found.
         """
         model_class = type(model_instance)
         table_name = model_class.get_table_name()
-
         primary_key = model_class.get_primary_key()
 
-        fields = ", ".join(
-            f"{field} = ?"
-            for field in model_class.model_fields
-            if field != primary_key
-        )
-        values = tuple(
-            getattr(model_instance, field)
-            for field in model_class.model_fields
-            if field != primary_key
-        )
-        primary_key_value = getattr(model_instance, primary_key)
+        # Set updated_at timestamp
+        current_timestamp = int(time.time())
+        model_instance.updated_at = current_timestamp
+
+        # Get the data and serialize any datetime/date fields
+        data = model_instance.model_dump()
+        for field_name, value in list(data.items()):
+            data[field_name] = model_instance.serialize_field(value)
+
+        # Remove the primary key from the update data
+        primary_key_value = data.pop(primary_key)
+
+        # Create the SQL using the processed data
+        fields = ", ".join(f"{field} = ?" for field in data)
+        values = tuple(data.values())
 
         update_sql = f"""
             UPDATE {table_name}
@@ -515,6 +667,7 @@ class SqliterDB:
 
         """
         self.connect()
+        self._in_transaction = True
         return self
 
     def __exit__(
@@ -552,3 +705,4 @@ class SqliterDB:
                 # Close the connection and reset the instance variable
                 self.conn.close()
                 self.conn = None
+                self._in_transaction = False

{sqliter_py-0.5.0.dist-info → sqliter_py-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sqliter-py
-Version: 0.5.0
+Version: 0.7.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
@@ -60,8 +60,7 @@ Website](https://sqliter.grantramsay.dev)
 > Also, structures like `list`, `dict`, `set` etc are not supported **at this
 > time** as field types, since SQLite does not have a native column type for
 > these. This is the **next planned enhancement**. These will need to be
-> `pickled` first then stored as a BLOB in the database . Also support `date`
-> which can be stored as a Unix timestamp in an integer field.
+> `pickled` first then stored as a BLOB in the database.
 >
 > See the [TODO](TODO.md) for planned features and improvements.
 
@@ -75,6 +74,10 @@ Website](https://sqliter.grantramsay.dev)
 ## Features
 
 - Table creation based on Pydantic models
+- Supports `date` and `datetime` fields. List/Dict/Set fields are planned.
+- 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.7.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+sqliter/__init__.py,sha256=ECfn02OPmiMCQvRYbfizKFhVDk00xV-HV1s2cH9037I,244
+sqliter/constants.py,sha256=clai8tiF6g9raTKUvEcBA5srmLePa6GFX7zC4YQ_6Zo,1186
+sqliter/exceptions.py,sha256=g-YZaPazBxlYxQ0lVP_MCWC-mQlX_qgyWip5LJCVLV4,5654
+sqliter/helpers.py,sha256=d6k4oWl43Se_c8rAmX8Zj0_sf2O-bpaaeu33VN2IcsI,3442
+sqliter/sqliter.py,sha256=Cvko-UqmdXbZqkVTglBlVAKUyPcDyiuiOjeNY6-_2EI,24340
+sqliter/model/__init__.py,sha256=MblCLIdoUwvRQmTALxXTadW54vH8SyOShonkzktbH5A,396
+sqliter/model/model.py,sha256=yc-fbiDa2swNd5yl1x-QP0vqeRTCPMpfZbIA6yG8k7M,7393
+sqliter/model/unique.py,sha256=r4CXrW1GXB6OgNoOVDTpTEVZl8_zta3mYbbT5quMc-c,578
+sqliter/query/__init__.py,sha256=MRajhjTPJqjbmmrwndVKj8vqMbK5-XufpwoIswQf5z4,239
+sqliter/query/query.py,sha256=GL3Wh7jQY5n-X1oacVoHIFBTUa-zQJwzx8TM_ZEeuVE,24657
+sqliter_py-0.7.0.dist-info/METADATA,sha256=ApjziCgXFt-N3KC_ogS1KuRV7_YRjoV2Plxv1HBBPzA,7395
+sqliter_py-0.7.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+sqliter_py-0.7.0.dist-info/licenses/LICENSE.txt,sha256=-r4mvgoEWzkl1hPO5k8I_iMwJate7zDj8p_Fmn7dhVg,1078
+sqliter_py-0.7.0.dist-info/RECORD,,

sqliter_py-0.5.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-sqliter/__init__.py,sha256=ECfn02OPmiMCQvRYbfizKFhVDk00xV-HV1s2cH9037I,244
-sqliter/constants.py,sha256=j0lE2cB1Uj8cNo40GGtCPdOR5asm-dHRDmGG0oyindA,1050
-sqliter/exceptions.py,sha256=g6jjcBnU2wnd_Sz90PCARl8PRayhU-D88W0tIUh548A,4808
-sqliter/helpers.py,sha256=75r4zMmGztVPm9_Bz3L1cSvBdx17uPEAnaggVhD70Pg,1138
-sqliter/sqliter.py,sha256=XLMIZZfMdRFv7iyGLH6N9uHE_0bAIxgvxgLxADYAjv8,18545
-sqliter/model/__init__.py,sha256=GgULmKRn0Dq0Jz6LbHGPndS6GP3vd1uxI1KrEevofLs,237
-sqliter/model/model.py,sha256=1aLe0QX5HEovOb9U6F9i_-fs4JqpPpewafd8KWINAkQ,4595
-sqliter/query/__init__.py,sha256=MRajhjTPJqjbmmrwndVKj8vqMbK5-XufpwoIswQf5z4,239
-sqliter/query/query.py,sha256=g9MbF3AGqNNha7QStxNv1qtIXv0A9FUgerur_0qhu8U,24081
-sqliter_py-0.5.0.dist-info/METADATA,sha256=-kRDsXK1GrxUoL3B9uNEMwnsNUwhGsUjYGuNsjSxZ2g,7271
-sqliter_py-0.5.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-sqliter_py-0.5.0.dist-info/licenses/LICENSE.txt,sha256=-r4mvgoEWzkl1hPO5k8I_iMwJate7zDj8p_Fmn7dhVg,1078
-sqliter_py-0.5.0.dist-info/RECORD,,