sqlite-database 0.7.4__tar.gz → 0.7.5__tar.gz

{sqlite_database-0.7.4/sqlite_database.egg-info → sqlite_database-0.7.5}/PKG-INFO

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

{sqlite_database-0.7.4 → sqlite_database-0.7.5}/docs/ModelAPI.md

@@ -159,7 +159,7 @@ Here’s a small CLI app to tie it all together:
 ```py
 from enum import IntEnum
 from uuid import uuid4
-from sqlite_database import Database, model, BaseModel, Primary
+from sqlite_database import Database, model, BaseModel, Primary, Null
 
 db = Database(":memory:")
 
@@ -180,6 +180,12 @@ def display():
         print(f"Content : {note.content}")
         print("-"*3)
 
+def read(prompt: str):
+    try:
+        return input(prompt)
+    except KeyboardInterrupt:
+        return Null
+
 def create():
     title = input("Title: ")
     content = input("Content: ")
@@ -189,8 +195,8 @@ def update():
     note_id = input('ID: ')
     note = Notes.first(id=note_id)
     if note:
-        title = input("New title: ")
-        content = input("New content: ")
+        title = read("New title: ")
+        content = read("New content: ")
         note.update(title=title, content=content)
     else:
         print("Note not found.")

{sqlite_database-0.7.4 → sqlite_database-0.7.5}/sqlite_database/__init__.py

@@ -1,6 +1,6 @@
 """Database"""
 
-from .models import BaseModel, model, Foreign, Primary, Unique
+from .models import BaseModel, model, Foreign, Primary, Unique, hook, validate
 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.4"
+__version__ = "0.7.5"
 __all__ = [
     "Database",
     "Table",
@@ -32,5 +32,8 @@ __all__ = [
     "models",
     "Foreign",
     "Primary",
-    "Unique"
+    "Unique",
+    "model",
+    "hook",
+    "validate"
 ]

{sqlite_database-0.7.4 → sqlite_database-0.7.5}/sqlite_database/_utils.py

@@ -66,6 +66,7 @@ class Sentinel: # pylint: disable=too-few-public-methods
     Pre-defined value:
         - Null, use this one if you're unsure if the data you pulled exists or not.
             The query builder will remove it if it detects Null sentinel."""
+
     def __repr__(self) -> str:
         return "<Sentinel>"
 

{sqlite_database-0.7.4 → sqlite_database-0.7.5}/sqlite_database/models/__init__.py

@@ -1,13 +1,28 @@
 """Models"""
 
-# pylint: disable=unused-import,unused-argument,cyclic-import
+# pylint: disable=unused-import,unused-argument,cyclic-import,protected-access
 
 from contextlib import contextmanager
 from typing import Any, Callable, Self, Type, TypeVar, overload
 from dataclasses import asdict, dataclass, fields, is_dataclass, MISSING
 
-from .helpers import (Constraint, Unique, Primary, Foreign, TYPES, Validators,
-                      CASCADE, DEFAULT, NOACT, RESTRICT, SETNULL)
+from sqlite_database.models.type_checkers import typecheck
+
+from .helpers import (
+    Constraint,
+    Unique,
+    Primary,
+    Foreign,
+    TYPES,
+    Validators,
+    CASCADE,
+    DEFAULT,
+    NOACT,
+    RESTRICT,
+    SETNULL,
+)
+
+from .helpers import VALID_HOOKS_NAME, hook, validate, initiate_hook, initiate_validators
 from .query_builder import QueryBuilder
 from .errors import ConstraintError
 from ..errors import DatabaseExistsError
@@ -18,22 +33,15 @@ from ..operators import in_
 NULL = object()
 T = TypeVar("T", bound="BaseModel")
 
-VALID_HOOKS_NAME = (
-    "before_create",
-    "after_create",
-    "before_update",
-    "after_update",
-    "before_delete",
-    "after_delete",
-)
-
 ## Model functions
 
+
 @staticmethod
 def noop_autoid():
     """Default no-op function for BaseModel __auto_id__"""
     return None
 
+
 class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-methods
     """Base class for all Models using Model API"""
 
@@ -42,7 +50,7 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
     __validators__: dict[str, list[Validators]] = {}
     __hooks__: "dict[str, list[Callable[[Self], None] | str]]" = {}
     __hidden__: tuple[str, ...] = ()
-    __auto_id__ = noop_autoid
+    __auto_id__: Callable[[], Any] = noop_autoid
     _tbl: Table
     _primary: str | None
 
@@ -94,26 +102,27 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
 
     @classmethod
     def _execute_hooks(cls, name: str, instance: Self):
-        for hook in cls.__hooks__.get(name, ()):
-            if isinstance(hook, str):
-                getattr(cls, hook)(instance)
+        for hook_fn in cls.__hooks__.get(name, ()):
+            if isinstance(hook_fn, str):
+                getattr(cls, hook_fn)(instance)
             else:
-                hook(instance)
+                hook_fn(instance)
 
     @classmethod
     def _execute_validators(cls, name: str, instance: Self):
-        for validator in cls.__validators__.get(name, ()):
-            validator.validate(instance)
+        for validator_fn in cls.__validators__.get(name, ()):
+            validator_fn.validate(instance)
 
     @classmethod
-    def _register(cls, type_: str = 'hook', name: str = "", if_fail: str = ""):
+    def _register(cls, type_: str = "hook", name: str = "", if_fail: str = ""):
         """Register a hook/validator under a name"""
         if type_ not in ("hook", "validator"):
             raise ValueError("Which do you want?")
+
         def function(func):
-            if name == '':
+            if name == "":
                 raise ValueError(f"{type_.title()} name needs to be declared.")
-            if type_ == 'hook':
+            if type_ == "hook":
                 if name not in VALID_HOOKS_NAME:
                     raise ValueError("Name of a hook doesn't match with expected value")
                 cls.__hooks__.setdefault(name, [])
@@ -128,26 +137,27 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
 
             fields_ = tuple((field.name for field in fields(cls)))
             if name not in fields_:
-                raise ValueError("Expected validator to has name as column field")
+                raise ValueError(f"Expected validator to has name as column field. Got {name!r}")
 
             fail = if_fail or f"{name} fails certain validator"
 
             cls.__validators__.setdefault(name, [])
-            validator = Validators(func, fail)
+            validator_entry = Validators(func, fail)
             if cls.__validators__[name]:
-                cls.__validators__[name] = [validator]
+                cls.__validators__[name] = [validator_entry]
             else:
-                cls.__validators__[name].append(validator)
+                cls.__validators__[name].append(validator_entry)
             return func
+
         return function
 
     @classmethod
     def create(cls, **kwargs):
         """Create data based on kwargs"""
-        primary: str | None = cls._primary or kwargs.get('id', None)
-        id_present = bool(kwargs.get('id', None))
-        if primary and cls.__auto_id__ and not id_present:
-            kwargs[primary] = cls.__auto_id__()
+        primary: str | None = cls._primary or kwargs.get("id", None)
+        id_present = bool(kwargs.get("id", None))
+        if primary and cls.__auto_id__ and not id_present:  # type: ignore
+            kwargs[primary] = cls.__auto_id__()  # type: ignore
         instance = cls(**kwargs)
 
         cls._execute_hooks("before_create", instance)
@@ -283,7 +293,9 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
         """Wrap instance that complies with __hidden__."""
         if is_dataclass(self):
             dict_inst = asdict(self).items()
-            instance = {k: (v if not k in self.__hidden__ else None) for k, v in dict_inst}
+            instance = {
+                k: (v if not k in self.__hidden__ else None) for k, v in dict_inst
+            }
             return type(self)(**instance)
         raise TypeError("This class must be a dataclass")
 
@@ -304,7 +316,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("/") # type: ignore
+                table_ref, _ = constraint.target.split("/")  # type: ignore
                 if table_ref == self.__class__.__name__.lower():
                     foreign_key = constraint.column
                     break
@@ -322,11 +334,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( # type: ignore
+            if isinstance(constraint, Foreign) and constraint.target.startswith(  # type: ignore
                 related_model.__table_name__ + "/"
             ):
                 foreign_key = constraint.column
-                referenced_column = constraint.target.split("/")[1] # type: ignore
+                referenced_column = constraint.target.split("/")[1]  # type: ignore
                 return related_model.where(
                     **{referenced_column: getattr(self, foreign_key)}
                 ).fetch_one()
@@ -351,16 +363,6 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
             f"with {self.__class__.__name__}"
         )
 
-    @classmethod
-    def hook(cls, name: str):
-        """Register a hook"""
-        return cls._register('hook', name)
-
-    @classmethod
-    def validator(cls, column_name: str, if_fail: str):
-        """Register a validator"""
-        return cls._register("validator", column_name, if_fail)
-
     def get_table(self):
         """Return table instance"""
         return self._tbl
@@ -375,9 +377,11 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
         """Return Query Builder related to this model"""
         return QueryBuilder(cls)
 
-def model(db: Database):
+def model(db: Database, type_checking: bool = False):
     """Initiate Model API compatible classes. Requires target to be a dataclass,
-    the app automatically injects dataclass if this isn't a dataclass"""
+    the app automatically injects dataclass if this isn't a dataclass.
+
+    Use `type_checking` if you want automatic runtime type checker."""
 
     def outer(cls: Type[T]) -> Type[T]:
         if not issubclass(cls, BaseModel):
@@ -385,6 +389,13 @@ def model(db: Database):
         if not is_dataclass(cls):
             cls = dataclass(cls)
         cls.create_table(db)
+        if type_checking:
+            for fn in typecheck(cls):
+                initiate_validators(cls, fn)
+
+        for member in cls.__dict__.values():
+            initiate_hook(cls, member)
+            initiate_validators(cls, member)
         return cls
 
     return outer
@@ -401,5 +412,7 @@ __all__ = [
     "DEFAULT",
     "NOACT",
     "SETNULL",
-    "RESTRICT"
+    "RESTRICT",
+    "validate",
+    "hook"
 ]

sqlite_database-0.7.5/sqlite_database/models/helpers.py

@@ -0,0 +1,215 @@
+"""Model helpers"""
+
+# pylint: disable=invalid-name,too-few-public-methods,abstract-method,protected-access
+
+from typing import Any, Callable, Type, TypeAlias, TypeVar, overload
+from enum import StrEnum
+
+import sqlite_database
+from .errors import ValidationError
+from ..column import BuilderColumn, text, integer, blob, boolean
+
+TypeFunction: TypeAlias = Callable[[str], BuilderColumn]
+Model = TypeVar("Model", bound="sqlite_database.BaseModel")
+FuncT = TypeVar("FuncT", bound=Callable[..., bool])
+BaseModel: TypeAlias = "sqlite_database.BaseModel"
+
+TYPES: dict[Type[Any], TypeFunction] = (
+    {  # pylint: disable=possibly-used-before-assignment
+        int: integer,
+        str: text,
+        bytes: blob,
+        bool: boolean,
+    }
+)
+
+VALID_HOOKS_NAME = (
+    "before_create",
+    "after_create",
+    "before_update",
+    "after_update",
+    "before_delete",
+    "after_delete",
+)
+
+
+class ConstraintEnum(StrEnum):
+    """Constraints for update/delete"""
+
+    RESTRICT = "restrict"
+    SETNULL = "null"
+    CASCADE = "cascade"
+    NOACT = "no act"
+    DEFAULT = "default"
+
+
+RESTRICT = ConstraintEnum.RESTRICT
+SETNULL = ConstraintEnum.SETNULL
+CASCADE = ConstraintEnum.CASCADE
+NOACT = ConstraintEnum.NOACT
+DEFAULT = ConstraintEnum.DEFAULT
+
+
+class Constraint:
+    """Base constraint class for models"""
+
+    def __init__(self, column: str) -> None:
+        self._column = column
+
+    @property
+    def column(self):
+        """Columns"""
+        return self._column
+
+    def apply(self, type_: BuilderColumn):
+        """Apply this constraint to an column"""
+        raise NotImplementedError()
+
+
+class Unique(Constraint):
+    """Unique constraint"""
+
+    def apply(self, type_: BuilderColumn):
+        type_.unique()
+
+
+class Foreign(Constraint):
+    """Foreign constraint"""
+
+    def __init__(self, column: str, target: str | Type[Model]) -> None:
+        super().__init__(column)
+        self._target = target
+        self.resolve()
+        self._base = target
+        self._on_delete = DEFAULT
+        self._on_update = DEFAULT
+
+    @property
+    def target(self):
+        """Target foreign constraint"""
+        return self._target
+
+    def on_delete(self, constraint: ConstraintEnum):
+        """On delete constraint"""
+        self._on_delete = constraint
+        return self
+
+    def on_update(self, constraint: ConstraintEnum):
+        """On update constraint"""
+        self._on_update = constraint
+        return self
+
+    def resolve(self):
+        """Resolve if current target is a Model"""
+        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:
+                raise ValueError(f"{type(self._target)} does not have primary key")
+            self._target = f"{name}/{target}"
+
+    def apply(self, type_: BuilderColumn):
+        type_.foreign(self._target)  # type: ignore
+        if self._on_delete != DEFAULT:
+            type_.on_delete(self._on_delete.value)
+        if self._on_update != DEFAULT:
+            type_.on_update(self._on_update.value)
+
+
+class Primary(Constraint):
+    """Primary constraint"""
+
+    def apply(self, type_: BuilderColumn):
+        """Apply this constraint as primary"""
+        type_.primary()
+
+
+class Validators:
+    """Base class to hold validators"""
+
+    def __init__(self, fn: Callable[[Any], bool], if_fail: str) -> None:
+        self._callable = fn
+        self._reason = if_fail
+
+    def validate(self, instance: BaseModel):
+        """Validate a value"""
+        if not self._callable(instance):
+            err = ValidationError(self._reason)
+            err.add_note(str(instance))
+            raise err
+        return True
+
+
+@overload
+def hook(fn_or_name: Callable[[Model], None]) -> "staticmethod[[Callable[[Model], None]], None]":
+    pass
+
+
+@overload
+def hook(fn_or_name: str):
+    pass
+
+
+def hook(fn_or_name):
+    """Register a hook"""
+
+    def decorator(func):
+        fn = staticmethod(func)
+        fn_name = func.__name__
+        final_name = fn_or_name if fn_name not in VALID_HOOKS_NAME else fn_name
+
+        if final_name is None:
+            raise ValueError("Hooks name is not valid. Provide with @hook(name)")
+        fn._hooks_info = (fn_or_name  # type: ignore
+                          if fn_name not in VALID_HOOKS_NAME else fn_name,)
+        return fn
+
+    return decorator(fn_or_name) if callable(fn_or_name) else decorator
+
+
+@overload
+def validate(fn_or_column: FuncT) -> "staticmethod[[FuncT], bool]":
+    pass
+
+
+@overload
+def validate(fn_or_column: str, reason: str | None = None):  # type: ignore
+    pass
+
+
+def validate(fn_or_column, reason=None):
+    """Register a validator"""
+
+    def decorator(func: Callable):
+        print(func, fn_or_column)
+        fn = staticmethod(func)
+        name = func.__name__
+        inferred_col = (
+            name[len("validate_") :] if name.startswith("validate_") else None
+        )
+
+        col = fn_or_column or inferred_col
+        if callable(col):
+            col = inferred_col
+        if col is None:
+            raise ValueError("Validator must have a column name.")
+
+        msg = reason or func.__doc__ or f"Validation failed for '{col}'"
+        fn._validators_info = (col, msg)  # type: ignore
+        return fn
+
+    return decorator(fn_or_column) if callable(fn_or_column) else decorator
+
+
+def initiate_hook(cls: Type[BaseModel], member: Callable):
+    """Initiate hooks"""
+    if hasattr(member, "_hooks_info"):
+        info = member._hooks_info
+        cls._register("hook", info[0])(member)
+
+
+def initiate_validators(cls: Type[BaseModel], member: Callable):
+    """Initiate validators"""
+    if hasattr(member, "_validators_info"):
+        info = member._validators_info
+        cls._register("validator", info[0], info[1])(member)

sqlite_database-0.7.5/sqlite_database/models/type_checkers.py

@@ -0,0 +1,27 @@
+"""Type checking"""
+
+from typing import TYPE_CHECKING, Any, Type
+from dataclasses import fields, is_dataclass
+from .helpers import validate
+
+if TYPE_CHECKING:
+    from . import BaseModel
+
+def infer_type(name: str, type_: "Type[Any]"):
+    """Infer type checking for specific columns"""
+    if not isinstance(type_, type):
+        return None
+
+    @validate(name, f"{name} type is not {type_.__name__}") # type: ignore
+    def function(instance: "Type[BaseModel]"):
+        return isinstance(getattr(instance, name), type_)
+    return function
+
+def typecheck(cls: "Type[BaseModel]"):
+    """Automatically pushed Runtime type checking"""
+    if not is_dataclass(cls):
+        raise TypeError(f"{cls.__name__} is not a dataclass")
+
+    for field in fields(cls):
+        name, type_ = field.name, field.type
+        yield infer_type(name, type_) # type: ignore