sqlite-database 0.7.2__tar.gz → 0.7.3__tar.gz

{sqlite_database-0.7.2 → sqlite_database-0.7.3}/.github/workflows/python-publish.yml

@@ -11,6 +11,7 @@ name: Upload Python Package
 on:
   release:
     types: [published]
+  workflow_dispatch:
 
 permissions:
   contents: read

{sqlite_database-0.7.2/sqlite_database.egg-info → sqlite_database-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlite_database
-Version: 0.7.2
+Version: 0.7.3
 Summary: A weird wrapper for SQLite Connection
 Home-page: https://github.com/RimuEirnarn/sqlite_database
 Author: RimuEirnarn

{sqlite_database-0.7.2 → sqlite_database-0.7.3}/pyproject.toml

@@ -25,7 +25,7 @@ Repository = "https://github.com/RimuEirnarn/sqlite_database.git"
 
 [tool.setuptools]
 zip-safe = true
-packages = ["sqlite_database", "sqlite_database.model"]
+packages = ["sqlite_database", "sqlite_database.models"]
 
 [project.optional-dependencies]
 dev = ["pytest", "pylint", "black"]

{sqlite_database-0.7.2 → sqlite_database-0.7.3}/sqlite_database/__init__.py

@@ -1,6 +1,6 @@
 """Database"""
 
-from .model import BaseModel, model, Foreign, Primary, Unique
+from .models import BaseModel, model, Foreign, Primary, Unique
 from .database import Database
 from ._utils import null, Row, Null
 from .column import Column, text, integer, blob, real
@@ -14,7 +14,7 @@ def test_installed():
     return True
 
 
-__version__ = "0.7.2"
+__version__ = "0.7.3"
 __all__ = [
     "Database",
     "Table",
@@ -29,7 +29,7 @@ __all__ = [
     "real",
     "blob",
     "BaseModel",
-    "model",
+    "models",
     "Foreign",
     "Primary",
     "Unique"

{sqlite_database-0.7.2/sqlite_database/model → sqlite_database-0.7.3/sqlite_database/models}/__init__.py

@@ -210,6 +210,12 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
         """Delete multiple records using a primary key."""
         cls._tbl.delete({key: in_(keys)})
 
+    @classmethod
+    def first_or_fail(cls, **kwargs):
+        """Return the first matching record or raise an error if no match is found."""
+        result = cls.where(**kwargs).limit(1).throw().fetch_one()
+        return result
+
     @classmethod
     def first(cls, **kwargs):
         """Return the first matching record or None if no match is found."""
@@ -224,6 +230,18 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
             raise ValueError(f"Expected one record, but found {len(results)}")
         return results[0] if results else None
 
+    @classmethod
+    def find(cls, amount: int):
+        """Return models relative to the amount"""
+        results = cls.query().limit(amount).fetch()
+        return results
+
+    @classmethod
+    def find_or_fail(cls, amount: int):
+        """Return models relative to the amount and when returned is equal to 0, throws an error"""
+        results = cls.query().limit(amount).throw().fetch()
+        return results
+
     @classmethod
     def all(cls):
         """Return all values from the table"""
@@ -261,7 +279,7 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
             return {k: v for k, v in instance.items() if k not in self.__hidden__}
         return {}
 
-    def to_safe_instance(self):
+    def to_safe_instance(self) -> Self:
         """Wrap instance that complies with __hidden__."""
         if is_dataclass(self):
             dict_inst = asdict(self).items()
@@ -286,7 +304,7 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
         # Scan __schema__ of related model to find a Foreign key linking back
         for constraint in related.__schema__:
             if isinstance(constraint, Foreign):
-                table_ref, _ = constraint.target.split("/")
+                table_ref, _ = constraint.target.split("/") # type: ignore
                 if table_ref == self.__class__.__name__.lower():
                     foreign_key = constraint.column
                     break
@@ -304,11 +322,11 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
         """Retrieve the related model that this instance belongs to."""
         # Find the Foreign() constraint that references `related_model`
         for constraint in self.__schema__:
-            if isinstance(constraint, Foreign) and constraint.target.startswith(
+            if isinstance(constraint, Foreign) and constraint.target.startswith( # type: ignore
                 related_model.__table_name__ + "/"
             ):
                 foreign_key = constraint.column
-                referenced_column = constraint.target.split("/")[1]
+                referenced_column = constraint.target.split("/")[1] # type: ignore
                 return related_model.where(
                     **{referenced_column: getattr(self, foreign_key)}
                 ).fetch_one()
@@ -379,4 +397,9 @@ __all__ = [
     "Primary",
     "Foreign",
     "QueryBuilder",
+    "CASCADE",
+    "DEFAULT",
+    "NOACT",
+    "SETNULL",
+    "RESTRICT"
 ]

{sqlite_database-0.7.2/sqlite_database/model → sqlite_database-0.7.3/sqlite_database/models}/errors.py

@@ -1,9 +1,12 @@
-"""Error modules"""
-
-from ..errors import UnexpectedResultError
-
-class ValidationError(ValueError):
-    """Specific validation error; a value fails validation test"""
-
-class ConstraintError(UnexpectedResultError):
-    """Specific constraint is found twice, thrice, etc."""
+"""Error modules"""
+
+from ..errors import UnexpectedResultError
+
+class ValidationError(ValueError):
+    """Specific validation error; a value fails validation test"""
+
+class ConstraintError(UnexpectedResultError):
+    """Specific constraint is found twice, thrice, etc."""
+
+class NoDataReturnedError(ValueError):
+    """Data fetched from model cannot be retrieved"""

{sqlite_database-0.7.2/sqlite_database/model → sqlite_database-0.7.3/sqlite_database/models}/helpers.py

@@ -5,7 +5,7 @@ from typing import Any, Callable, Type, TypeAlias, TypeVar
 from enum import StrEnum
 
 import sqlite_database
-from sqlite_database.model.errors import ValidationError
+from .errors import ValidationError
 from ..column import BuilderColumn, text, integer, blob, boolean
 
 TypeFunction: TypeAlias = Callable[[str], BuilderColumn]
@@ -80,7 +80,7 @@ class Foreign(Constraint):
 
     def resolve(self):
         """Resolve if current target is a Model"""
-        if issubclass(self._target, sqlite_database.BaseModel):
+        if issubclass(self._target, sqlite_database.BaseModel): # type: ignore
             name = self._target.__table_name__
             target = self._target._primary # pylint: disable=protected-access
             if not target:
@@ -88,7 +88,7 @@ class Foreign(Constraint):
             self._target = f"{name}/{target}"
 
     def apply(self, type_: BuilderColumn):
-        type_.foreign(self._target)
+        type_.foreign(self._target) # type: ignore
         if self._on_delete != DEFAULT:
             type_.on_delete(self._on_delete.value)
         if self._on_update != DEFAULT:

{sqlite_database-0.7.2/sqlite_database/model → sqlite_database-0.7.3/sqlite_database/models}/query_builder.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 from typing import Any, Generic, Type, TypeVar
+from .errors import NoDataReturnedError
 from ..column import check_one
 from ..functions import Function
-from .. import model as models # pylint: disable=unused-import
+from .. import models # pylint: disable=unused-import
 
 T = TypeVar("T", bound="models.BaseModel")
 count = Function('COUNT')
@@ -19,6 +20,12 @@ class QueryBuilder(Generic[T]):
         self._limit = 0
         self._offset = 0
         self._order = None
+        self._failing = False
+
+    def throw(self):
+        """Set when fetch() returns nothing, will raise an error"""
+        self._failing = True
+        return self
 
     def where(self, **kwargs):
         """Sets conditioning"""
@@ -42,19 +49,25 @@ class QueryBuilder(Generic[T]):
 
     def fetch(self) -> list[T]:
         """Fetch data from table"""
-        return [
-            self._model(**record)
-            for record in self._model._tbl.select(  # pylint: disable=protected-access
+        records = self._model._tbl.select(  # pylint: disable=protected-access
                 self._filters, limit=self._limit, offset=self._offset, order=self._order
             )
+        if len(records) == 0 and self._failing:
+            raise NoDataReturnedError(f"Model {self._model.__name__} has no data for current scope")
+        return [
+            self._model(**record) for record in records
         ]
 
-    def fetch_one(self) -> T:
+    def fetch_one(self) -> T | None:
         """Fetch one data from table"""
         # pylint: disable=protected-access
         record = self._model._tbl.select_one(
             self._filters, order=self._order
         )
+        if not record and self._failing:
+            raise NoDataReturnedError(f"Model {self._model.__name__} has no data for current scope")
+        if not record:
+            return None
         return self._model(**record)
 
     def count(self) -> int:

{sqlite_database-0.7.2 → sqlite_database-0.7.3/sqlite_database.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlite_database
-Version: 0.7.2
+Version: 0.7.3
 Summary: A weird wrapper for SQLite Connection
 Home-page: https://github.com/RimuEirnarn/sqlite_database
 Author: RimuEirnarn

{sqlite_database-0.7.2 → sqlite_database-0.7.3}/sqlite_database.egg-info/SOURCES.txt

@@ -81,11 +81,11 @@ sqlite_database.egg-info/dependency_links.txt
 sqlite_database.egg-info/requires.txt
 sqlite_database.egg-info/top_level.txt
 sqlite_database.egg-info/zip-safe
-sqlite_database/model/__init__.py
-sqlite_database/model/errors.py
-sqlite_database/model/helpers.py
-sqlite_database/model/mixin.py
-sqlite_database/model/query_builder.py
+sqlite_database/models/__init__.py
+sqlite_database/models/errors.py
+sqlite_database/models/helpers.py
+sqlite_database/models/mixin.py
+sqlite_database/models/query_builder.py
 tests/__init__.py
 tests/manual_test_performances.py
 tests/test_database.py

{sqlite_database-0.7.2 → sqlite_database-0.7.3}/tests/test_database.py

@@ -15,9 +15,9 @@ from pytest import raises
 
 from sqlite_database._debug import STATE
 from sqlite_database import Column, Database, integer, text, Null
-from sqlite_database.model import Primary, Unique, model, BaseModel, Foreign, CASCADE
-from sqlite_database.model.errors import ValidationError
-from sqlite_database.model.mixin import ChunkableMixin, ScopeMixin
+from sqlite_database.models import Primary, Unique, model, BaseModel, Foreign, CASCADE
+from sqlite_database.models.errors import ValidationError, NoDataReturnedError
+from sqlite_database.models.mixin import ChunkableMixin, ScopeMixin
 from sqlite_database.signature import op
 from sqlite_database.operators import eq, in_, this
 from sqlite_database.errors import TableRemovedError, CuteDemonLordException
@@ -384,7 +384,7 @@ def test_07_00_export_csv():
     database = Database(":memory:")
     setup_database(database)
     csv = to_csv_string(database)
-    print("test_06_export_csv\n", csv, "\n", file=pstdout, flush=True)
+    print("test_07_00_export_csv\n", csv, "\n", file=pstdout, flush=True)
     assert csv
 
 
@@ -614,6 +614,29 @@ def test_11_05_model_hidden():
     assert "password" not in admin_dict
     assert admin.to_safe_instance().password is None
 
+def test_11_06_model_fail():
+    """Test 1105 Model API __hidden__"""
+
+    db = Database(":memory:")
+
+    def auto_id():
+        return str(uuid4())
+
+    @model(db)
+    class Users(BaseModel):
+        """Base User class"""
+
+        __schema__ = (Primary("id"),)
+        __auto_id__ = auto_id
+        __hidden__ = ("password",)
+        id: str
+        username: str
+        password: str
+
+    Users.first()
+    with raises(NoDataReturnedError):
+        Users.find_or_fail(1)
+
 def test_98_00_test():
     """Gradual test"""
     db = Database(":memory:")