sqlite-database 0.7.6__tar.gz → 0.7.8__tar.gz

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/.gitignore

@@ -174,3 +174,4 @@ perf-counter.txt
 
 /transient/*
 !/transient/README.md
+transient.db

{sqlite_database-0.7.6/sqlite_database.egg-info → sqlite_database-0.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlite_database
-Version: 0.7.6
+Version: 0.7.8
 Summary: A weird wrapper for SQLite Connection
 Home-page: https://github.com/RimuEirnarn/sqlite_database
 Author: RimuEirnarn
@@ -79,6 +79,29 @@ You can read why this library exists by reading [the history](History.md). The p
 
 You can submit any issue if you found a good issue. You can submit a pull request as long as the thing you want complies with what this project aims for.
 
+## Development
+
+When pulling this repository with latest commit, make sure to install all `dev-requirements.txt` depending on your intentions. It's mostly pylint and pytest.
+
+When using `pytest`, do this: `pytest --config-file=./dev-config/pytest.ini` or check any check scripts in `bin/`
+
+### How to install?
+
+```sh
+git clone https://github.com/RimuEirnarn/sqlite_database
+cd sqlite_database
+
+python -m venv .venv
+.venv/bin/activate
+
+pip install -r ./dev-requirements.txt
+./bin/check.sh
+
+# Above script is equivalent to:
+pylint --rcfile ./dev-config/pylint.toml sqlite_database
+pytest --config-file ./dev-config/pytest.ini
+```
+
 ## License
 
 This library/wrapper/repo/project is licensed with/in BSD 3-Clause "New" or "Revised" License.

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/README.md

@@ -53,6 +53,29 @@ You can read why this library exists by reading [the history](History.md). The p
 
 You can submit any issue if you found a good issue. You can submit a pull request as long as the thing you want complies with what this project aims for.
 
+## Development
+
+When pulling this repository with latest commit, make sure to install all `dev-requirements.txt` depending on your intentions. It's mostly pylint and pytest.
+
+When using `pytest`, do this: `pytest --config-file=./dev-config/pytest.ini` or check any check scripts in `bin/`
+
+### How to install?
+
+```sh
+git clone https://github.com/RimuEirnarn/sqlite_database
+cd sqlite_database
+
+python -m venv .venv
+.venv/bin/activate
+
+pip install -r ./dev-requirements.txt
+./bin/check.sh
+
+# Above script is equivalent to:
+pylint --rcfile ./dev-config/pylint.toml sqlite_database
+pytest --config-file ./dev-config/pytest.ini
+```
+
 ## License
 
 This library/wrapper/repo/project is licensed with/in BSD 3-Clause "New" or "Revised" License.

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/TODO.md

@@ -9,11 +9,11 @@
 What API should we bring? These todo's is for simplification; you can do anything with `Database.sql` property
 
 - [x] sqlite function support
-- [ ] sqlite aggregate function support
-- [ ] sqlite window function support
-- [ ] sqlite collation support
+- [x] sqlite aggregate function support
+- [x] sqlite window function support
+- [x] sqlite collation support
 - [x] sqlite pragma
-- [ ] sqlite branching subquery (??)
+- [x] sqlite branching subquery (??)
 - [ ] sqlite 'as' keyword (??)
 - [x] sqlite select data crunching[^1] by using Database config option (crunch=True)
 - [x] sqlite select 'only' data. Instead of using `select *`, we should also have `only`. Bring up few data than select everything.[^2]
@@ -25,7 +25,7 @@ The functionality here is outside of sqlite features such as export and import.
 
 - [ ] YAML/JSON/TOML/CUSTOM scheme/table include
 - [x] CSV Export
-- [ ] CSV Import
+- [x] CSV Import
 
 1. abc
    - a

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/sqlite_database/__init__.py

@@ -1,5 +1,6 @@
 """Database"""
 
+from . import models
 from .models import BaseModel, model, Foreign, Primary, Unique, hook, validate
 from .database import Database
 from ._utils import Row, Null
@@ -14,7 +15,7 @@ def test_installed():
     return True
 
 
-__version__ = "0.7.6"
+__version__ = "0.7.8"
 __all__ = [
     "Database",
     "Table",

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/sqlite_database/_debug.py

@@ -39,7 +39,7 @@ def if_debug_print(*args, sep=" ", end="\n", flush=True):
         arg0 = args[0]
         print(
             arg0,
-            *(repr(arg) for arg in args if args.index(arg) != 0),
+            *(repr(arg) if arg != "\n" else "\n" for arg in args if args.index(arg) != 0),
             sep=sep,
             end=end,
             flush=flush,

sqlite_database-0.7.8/sqlite_database/asyncs/__init__.py

@@ -0,0 +1,3 @@
+"""Asyncs"""
+from .table import AsyncTable
+from .database import AsyncDatabase

sqlite_database-0.7.8/sqlite_database/asyncs/database.py

@@ -0,0 +1,37 @@
+"""AsyncDatabase"""
+
+from sqlite3 import connect, Connection
+from threading import local
+
+from .table import AsyncTable
+from ..database import Database
+from .._utils import dict_factory
+
+
+class AsyncDatabase(Database):
+    """Async (threads, subprocess) ready"""
+
+    def __init__(self, path: str, **kwargs) -> None:
+        self._local = local()
+        self._table_class = AsyncTable
+        super().__init__(path, **kwargs)
+
+    def _create_connection(self):
+        conn = getattr(self._local, "conn", None)
+        if conn is None:
+            timeout = self._kwargs.pop('timeout', 30)
+            conn = connect(
+                self._path,
+                timeout=timeout,
+                isolation_level=self._kwargs.pop("isolation_level", None),
+                check_same_thread=self._kwargs.pop("check_same_thread", False)
+            )
+            conn.row_factory = dict_factory
+            conn.execute("PRAGMA journal_mode=WAL;")
+            if isinstance(timeout, int):
+                conn.execute(f'PRAGMA busy_timeout={timeout * 1000};')
+            self._local.conn = conn
+
+    @property
+    def _database(self) -> Connection:
+        return self._local.conn

sqlite_database-0.7.8/sqlite_database/asyncs/table.py

@@ -0,0 +1,95 @@
+"""Async Table"""
+
+# pylint: disable=invalid-overridden-method
+import asyncio
+from contextvars import ContextVar
+
+from ..table import Table
+from ..query_builder import Condition
+from ..typings import Orders
+
+# Context-local transaction depth stack per async task
+_tx_stack = ContextVar("_tx_stack", default=[])
+
+
+class AsyncTable(Table):
+    """Async (threading/multiprocess ready) Table"""
+
+    def __init__(self, parent, table: str, columns=None, aggressive_select=False):
+        super().__init__(parent, table, columns, False)
+        if (self._columns is None and aggressive_select) and table != "sqlite_master":
+            asyncio.get_event_loop().run_until_complete(
+                asyncio.to_thread(self._fetch_columns)
+            )
+
+    async def _begin_transaction(self):
+        """Start a transaction or savepoint depending on depth."""
+        stack = list(_tx_stack.get())  # copy since ContextVar values are immutable
+        depth = len(stack)
+
+        if depth == 0:
+            await asyncio.to_thread(self._sql.execute, "BEGIN TRANSACTION")
+        else:
+            savepoint_name = f"sp_{depth}"
+            await asyncio.to_thread(self._sql.execute, f"SAVEPOINT {savepoint_name}")
+
+        stack.append(True)
+        _tx_stack.set(stack)
+
+    async def _commit_transaction(self):
+        """Commit or release savepoint depending on depth."""
+        stack = list(_tx_stack.get())
+        depth = len(stack)
+
+        if depth == 1:
+            await asyncio.to_thread(self._sql.commit)
+        elif depth > 1:
+            savepoint_name = f"sp_{depth-1}"
+            await asyncio.to_thread(
+                self._sql.execute, f"RELEASE SAVEPOINT {savepoint_name}"
+            )
+
+        stack.pop()
+        _tx_stack.set(stack)
+
+    async def _rollback_transaction(self):
+        """Rollback or rollback to savepoint depending on depth."""
+        stack = list(_tx_stack.get())
+        depth = len(stack)
+
+        if depth == 1:
+            await asyncio.to_thread(self._sql.rollback)
+        elif depth > 1:
+            savepoint_name = f"sp_{depth-1}"
+            await asyncio.to_thread(
+                self._sql.execute, f"ROLLBACK TO SAVEPOINT {savepoint_name}"
+            )
+
+        stack.pop()
+        _tx_stack.set(stack)
+
+    # ✅ async context manager compatible with your original Table
+    async def __aenter__(self):
+        await self._begin_transaction()
+        return self
+
+    async def __aexit__(self, exc_type, *_):
+        if exc_type:
+            await self._rollback_transaction()
+        else:
+            await self._commit_transaction()
+
+    async def begin(self):
+        """Begin"""
+        await self._begin_transaction()
+
+    async def commit(self):
+        await self._commit_transaction()
+
+    async def rollback(self):
+        await self._rollback_transaction()
+
+    async def delete(
+        self, where: Condition = None, limit: int = 0, order: Orders | None = None
+    ):
+        await asyncio.to_thread(self.delete, where, limit, order)

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/sqlite_database/csv.py

@@ -1,6 +1,6 @@
 """CSV module, used to export database/table to csv"""
 
-from csv import DictWriter
+from csv import DictWriter, DictReader
 from io import StringIO
 from os import mkdir
 from os.path import join as join_path, isfile, exists
@@ -65,3 +65,15 @@ def to_csv_file(table_or_database: Table | Database, file: str):
     with open(file, "w", encoding="utf-8") as fio:
         fio.write(readed)
     return True
+
+def from_csv_string(table: Table, data: str):
+    """Insert from CSV data"""
+    reader = DictReader(data)
+    for entry in reader:
+        table.insert(entry)
+
+def from_csv_file(table: Table, data: str):
+    """Insert from CSV file"""
+    with open(data, encoding='utf-8') as f:
+        fdata = f.read()
+    return from_csv_string(table, fdata)

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/sqlite_database/database.py

@@ -1,8 +1,7 @@
 """SQLite Database"""
 
 from atexit import register as finalize
-from sqlite3 import OperationalError, connect, Connection
-from threading import local
+from sqlite3 import OperationalError, connect
 from typing import Iterable, Literal, Optional
 
 from sqlite_database._debug import if_debug_print
@@ -46,6 +45,7 @@ class Database: # pylint: disable=too-many-instance-attributes
             del kwargs['strict']
         self._config = None
         self._closed = False
+        self._table_class = Table
         if not self._closed or self.__dict__.get("_initiated", False) is False:
             finalize(self._finalizer)
             self._initiated = True
@@ -119,7 +119,7 @@ class Database: # pylint: disable=too-many-instance-attributes
             raise DatabaseMissingError(f"table {table} does not exists.")
 
         try:
-            this_table = Table(self, table, __columns)
+            this_table = self._table_class(self, table, __columns)
         except OperationalError as exc:
             dberror = DatabaseMissingError(f"table {table} does not exists")
             dberror.add_note(f"{type(exc).__name__}: {exc!s}")
@@ -228,30 +228,3 @@ class Database: # pylint: disable=too-many-instance-attributes
     def sql(self):
         """SQL Connection"""
         return self._database
-
-class AsyncDatabase(Database):
-    """Async (threads, subprocess) ready"""
-
-    def __init__(self, path: str, **kwargs) -> None:
-        super().__init__(path, **kwargs)
-        self._local = local()
-
-    def _create_connection(self):
-        conn = getattr(self._local, "conn", None)
-        if conn is None:
-            timeout = self._kwargs.pop('timeout', 30)
-            conn = connect(
-                self._path,
-                timeout=timeout,
-                isolation_level=self._kwargs.pop("isolation_level", None),
-                check_same_thread=self._kwargs.pop("check_same_thread", False)
-            )
-            conn.row_factory = dict_factory
-            conn.execute("PRAGMA journal_mode=WAL;")
-            if isinstance(timeout, int):
-                conn.execute(f'PRAGMA busy_timeout={timeout * 1000};')
-            self._local.conn = conn
-
-    @property
-    def _database(self) -> Connection:
-        return self._local.conn

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/sqlite_database/models/__init__.py

@@ -155,7 +155,7 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
     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))
+        id_present = bool(kwargs.get(cls._primary or "id", None))
         if primary and cls.__auto_id__ and not id_present:  # type: ignore
             kwargs[primary] = cls.__auto_id__()  # type: ignore
         instance = cls(**kwargs)
@@ -363,9 +363,10 @@ class BaseModel:  # pylint: disable=too-few-public-methods,too-many-public-metho
             f"with {self.__class__.__name__}"
         )
 
-    def get_table(self):
+    @classmethod
+    def get_table(cls):
         """Return table instance"""
-        return self._tbl
+        return cls._tbl
 
     @classmethod
     def where(cls, **kwargs):

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/sqlite_database/query_builder.py

@@ -26,6 +26,8 @@ DEFAULT_MAPPINGS = {value: value for value in _SQLITETYPES}
 SQL_ACTIONS = {"null": "set null"}
 MAX_SUBQUERY_STACK_LIMIT = 10
 
+NAMING_FORMAT = "{key}{suffix}__{call_id}_{depth}_{condition_id}"
+
 
 def set_subquery_stack_limit(value: int):
     """Set subquery stack limit"""
@@ -200,7 +202,7 @@ def _handle_like(key, middle, val):
     return clause
 
 
-def extract_signature( # pylint: disable=too-many-locals
+def extract_signature(  # pylint: disable=too-many-locals
     filter_: Condition | CacheCond = None, suffix: str = "_check", depth: int = 0
 ):
     """Extract filter signature."""
@@ -227,7 +229,13 @@ def extract_signature( # pylint: disable=too-many-locals
 
         val = (
             Signature(
-                f":{key}_{call_id}_{depth}_{condition_id}_{suffix}",
+                ":"+NAMING_FORMAT.format(
+                    key=key,
+                    suffix=suffix,
+                    call_id=call_id,
+                    depth=depth,
+                    condition_id=condition_id,
+                ),
                 value.generate(),
                 value.data,
             )
@@ -257,7 +265,15 @@ def extract_signature( # pylint: disable=too-many-locals
             clauses.append(clause)
 
         if val.value is not null:
-            data[f"{key}_{call_id}_{depth}_{condition_id}_{suffix}"] = old_data
+            data[
+                NAMING_FORMAT.format(
+                    key=key,
+                    suffix=suffix,
+                    call_id=call_id,
+                    depth=depth,
+                    condition_id=condition_id,
+                )
+            ] = old_data
 
     if not clauses:
         return "", data

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/sqlite_database/table.py

@@ -1,8 +1,9 @@
 """Table"""
 
-# pylint: disable=too-many-arguments,too-many-public-methods
+# pylint: disable=too-many-arguments,too-many-public-methods,R0801
 
-from sqlite3 import Connection, OperationalError
+from contextvars import ContextVar
+from sqlite3 import Connection, Error, OperationalError
 from typing import (
     Any,
     Generator,
@@ -44,6 +45,7 @@ from .typings import (
 
 # Let's add a little bit of 'black' magic here.
 _null = Function("__NULL__")()
+_tx_stack = ContextVar("_tx_stack", default=[])
 
 class Table: # pylint: disable=too-many-instance-attributes
     """Table. Make sure you remember how the table goes."""
@@ -74,20 +76,40 @@ class Table: # pylint: disable=too-many-instance-attributes
         if (self._columns is None and aggresive_select) and table != "sqlite_master":
             self._fetch_columns()
 
+    # def __enter__(self):
+    #     self._prev_auto = self._auto
+    #     self._prev_autocommit = self._sql.isolation_level
+
+    #     self._sql.isolation_level = None
+    #     self._auto = False
+    #     self._sql.execute("BEGIN TRANSACTION")
+    #     return self
+
+    # def __exit__(self, exc_type, _, __):
+    #     if exc_type is None:
+    #         self._sql.commit()
+    #     else:
+    #         self._sql.rollback()
+    #     self._sql.isolation_level = self._prev_autocommit
+    #     self._auto = self._prev_auto
+
     def __enter__(self):
         self._prev_auto = self._auto
         self._prev_autocommit = self._sql.isolation_level
 
-        self._sql.isolation_level = None
         self._auto = False
-        self._sql.execute("BEGIN TRANSACTION")
+        self._sql.isolation_level = None
+        self._begin_transaction()
         return self
 
     def __exit__(self, exc_type, _, __):
         if exc_type is None:
-            self._sql.commit()
+            self._commit_transaction()
+            self._dirty = False
         else:
-            self._sql.rollback()
+            self._rollback_transaction()
+            self._dirty = False
+
         self._sql.isolation_level = self._prev_autocommit
         self._auto = self._prev_auto
 
@@ -167,10 +189,11 @@ class Table: # pylint: disable=too-many-instance-attributes
         fn = cursor.execute if which == "execute" else cursor.executemany
         try:
             fn(query, data)
-        except OperationalError as exc:
+        except Error as exc:
             if str(exc).startswith("no such table:"):
                 raise TableRemovedError(f"Table {self._table} doesn't exists anymore") from None
             exc.add_note(f"SQL query: {query}")
+            exc.add_note(f"Arguments: {data}")
             exc.add_note(
                 f"There's about {1 if isinstance(data, dict) else len(data)} value(s) inserted"
             )
@@ -587,12 +610,55 @@ constraint is enabled."
     def commit(self):
         """Commit changes"""
         self._sql.commit()
+        self._dirty = False
 
     def rollback(self):
         """Rollback"""
         self._sql.rollback()
         self._dirty = False
 
+    def _begin_transaction(self):
+        """Start a transaction or savepoint depending on depth."""
+        stack = list(_tx_stack.get())  # copy since ContextVar values are immutable
+        depth = len(stack)
+
+        if depth == 0:
+            self._sql.execute("BEGIN TRANSACTION")
+        else:
+            savepoint_name = f"sp_{depth}"
+            self._sql.execute(f"SAVEPOINT {savepoint_name}")
+
+        stack.append(True)
+        _tx_stack.set(stack)
+
+    def _commit_transaction(self):
+        """Commit or release savepoint depending on depth."""
+        stack = list(_tx_stack.get())
+        depth = len(stack)
+
+        if depth == 1:
+            self._sql.commit()
+        elif depth > 1:
+            savepoint_name = f"sp_{depth-1}"
+            self._sql.execute(f"RELEASE SAVEPOINT {savepoint_name}")
+        stack.pop()
+        _tx_stack.set(stack)
+
+    def _rollback_transaction(self):
+        """Rollback or rollback to savepoint depending on depth."""
+        stack = list(_tx_stack.get())
+        depth = len(stack)
+
+        if depth == 1:
+            self._sql.rollback()
+        elif depth > 1:
+            savepoint_name = f"sp_{depth-1}"
+            self._sql.execute(f"ROLLBACK TO SAVEPOINT {savepoint_name}"
+            )
+
+        stack.pop()
+        _tx_stack.set(stack)
+
     def count(self):
         """Count how much objects/rows stored in this table"""
         # ? Might as well uses __len__? But it's quite expensive.
@@ -601,13 +667,4 @@ constraint is enabled."
     def __repr__(self) -> str:
         return f"<Table({self._table}) -> {self._parent_repr}>"
 
-class AsyncTable(Table):
-    """Async (threads, subprocess) ready"""
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, _, __):
-        pass
-
 __all__ = ["Table"]

{sqlite_database-0.7.6 → sqlite_database-0.7.8/sqlite_database.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlite_database
-Version: 0.7.6
+Version: 0.7.8
 Summary: A weird wrapper for SQLite Connection
 Home-page: https://github.com/RimuEirnarn/sqlite_database
 Author: RimuEirnarn
@@ -79,6 +79,29 @@ You can read why this library exists by reading [the history](History.md). The p
 
 You can submit any issue if you found a good issue. You can submit a pull request as long as the thing you want complies with what this project aims for.
 
+## Development
+
+When pulling this repository with latest commit, make sure to install all `dev-requirements.txt` depending on your intentions. It's mostly pylint and pytest.
+
+When using `pytest`, do this: `pytest --config-file=./dev-config/pytest.ini` or check any check scripts in `bin/`
+
+### How to install?
+
+```sh
+git clone https://github.com/RimuEirnarn/sqlite_database
+cd sqlite_database
+
+python -m venv .venv
+.venv/bin/activate
+
+pip install -r ./dev-requirements.txt
+./bin/check.sh
+
+# Above script is equivalent to:
+pylint --rcfile ./dev-config/pylint.toml sqlite_database
+pytest --config-file ./dev-config/pytest.ini
+```
+
 ## License
 
 This library/wrapper/repo/project is licensed with/in BSD 3-Clause "New" or "Revised" License.

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/sqlite_database.egg-info/SOURCES.txt

@@ -82,6 +82,9 @@ 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/asyncs/__init__.py
+sqlite_database/asyncs/database.py
+sqlite_database/asyncs/table.py
 sqlite_database/models/__init__.py
 sqlite_database/models/errors.py
 sqlite_database/models/helpers.py

{sqlite_database-0.7.6 → sqlite_database-0.7.8}/tests/database/model_api/test_model_api.py

@@ -247,3 +247,18 @@ def test_model_api_query_builder_delete():
     admin = Users.create(id=auto_id(), username='admin', is_active=True)
 
     assert Users.where(id=admin.id).throw().delete() == 1, "Changes should be 1"
+
+def test_model_api_custom_id():
+    """Test Model API Custom Primary ID"""
+
+    db = Database(":memory:")
+    db.foreign_pragma('ON')
+
+    @model(db)
+    class Users(BaseModel):
+        __schema__ = (Primary('uid'),)
+
+        uid: str
+        username: str
+
+    assert Users.create(uid="1", username='admin')