sqlite-database 0.7.7__tar.gz → 0.7.9__tar.gz

{sqlite_database-0.7.7 → sqlite_database-0.7.9}/.gitignore

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

{sqlite_database-0.7.7/sqlite_database.egg-info → sqlite_database-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlite_database
-Version: 0.7.7
+Version: 0.7.9
 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.7 → sqlite_database-0.7.9}/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.7 → sqlite_database-0.7.9}/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.7 → sqlite_database-0.7.9}/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.7"
+__version__ = "0.7.9"
 __all__ = [
     "Database",
     "Table",

{sqlite_database-0.7.7 → sqlite_database-0.7.9}/sqlite_database/_utils.py

@@ -139,6 +139,13 @@ class WithCursor(Cursor):
     def __repr__(self) -> str:
         return type(self).__name__
 
+class NoopResource:
+    """No-op resource control"""
+    def close(self):
+        """Close this resource"""
+
+    def open(self, *_, **__):
+        """open something"""
 
 
 def test_installed():
@@ -162,4 +169,5 @@ __all__ = [
     "AttrDict",
     "NullObject",
     "sqlite_multithread_check",
+    "NoopResource"
 ]

{sqlite_database-0.7.7 → sqlite_database-0.7.9}/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.7 → sqlite_database-0.7.9}/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.7 → sqlite_database-0.7.9}/sqlite_database/errors.py

@@ -1,5 +1,7 @@
 """Errors"""
 
+class Rejection(RuntimeError):
+    """Cannot push into worker db"""
 
 class DependencyError(ImportError):
     """Specific dependency is missing"""
@@ -30,3 +32,12 @@ class ObjectRemovedError(BaseException):
 
 class CuteDemonLordException(Exception):
     """A demon lord (cute one, somehow a dude) aborts an SQL statement"""
+
+class FeatureGatekeep(ValueError):
+    """A feature is gatekeeped"""
+
+class VersionError(FeatureGatekeep):
+    """Current version cannot use this feature"""
+
+class ImplementationWarning(FutureWarning):
+    """The implementation of specific feature is not supported"""

{sqlite_database-0.7.7 → sqlite_database-0.7.9}/sqlite_database/models/__init__.py

@@ -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.7 → sqlite_database-0.7.9}/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,27 +610,61 @@ 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.
         return self.select(what=count("*"))
 
     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
+        return f"<{type(self).__name__}({self._table}) -> {self._parent_repr}>"
 
 __all__ = ["Table"]

sqlite_database-0.7.9/sqlite_database/workers/__init__.py

@@ -0,0 +1,5 @@
+"""Workers"""
+
+from .database import DatabaseWorker
+
+__all__ = ['DatabaseWorker']

sqlite_database-0.7.9/sqlite_database/workers/connection.py

@@ -0,0 +1,214 @@
+"""Worker Connection"""
+
+# pylint: disable=ungrouped-imports,possibly-used-before-assignment,too-few-public-methods,no-name-in-module,no-member
+
+# import os
+from sys import version_info
+from concurrent.futures import Future
+from queue import Empty, Queue
+from sqlite3 import Connection, Cursor
+# from multiprocessing import Event as EventProcess, Process, freeze_support
+from threading import Thread, Event as EventThread
+from typing import Any, Literal, TypeAlias
+from atexit import register as finalize
+import warnings
+
+from ..errors import Rejection, ImplementationWarning
+
+WorkerType: TypeAlias = Literal["thread"] | Literal["process"]
+FEATURE_MIN_VERSION = (3, 13)
+POSSIBLE_STACKTRACE_COUNT = 6
+
+if version_info > FEATURE_MIN_VERSION:
+    from queue import ShutDown  # type: ignore
+else:
+
+    class ShutDown(RuntimeError):
+        """Raised when put/get with shut-down queue."""
+
+
+def is_shutdown(worker: "Worker"):
+    """Is shutdown?"""
+    if worker.is_closed:
+        return lambda *a, **kw: None
+    return lambda *a, **kw: worker.push(worker.conn.close, "connection", *a, **kw)
+
+
+class Worker:
+    """Worker"""
+
+    def __init__(self, *args, worker_type: WorkerType = "thread", **kwargs):
+        self.conn = Connection(*args, **kwargs)
+        self.queue = Queue()
+        self.name = f"WorkerDB[{worker_type}]"
+        self.daemon = False
+        if worker_type in ("thread", "process"):
+            self.event = EventThread()
+            self.worker = Thread(target=self._run, name=self.name, daemon=self.daemon)
+        # elif worker_type == "process":
+            # freeze_support()
+            # self.event = EventProcess()
+            # self.worker = Process(target=self._run, name=self.name, daemon=self.daemon)
+        if worker_type == 'process':
+            warnings.warn(
+                "Worker Process implementation is not supported, reverting back to threading.",
+                ImplementationWarning,
+                POSSIBLE_STACKTRACE_COUNT)
+        self.accepting = self.event
+        self._closing = False
+        self.event.set()
+        self.worker.start()
+        finalize(self.close)
+
+    def recall(self):
+        """Recall remainding queues"""
+        while True:
+            try:
+                fn, _, args, kwargs, fut = self.queue.get_nowait()
+            except Empty:
+                break
+            try:
+                if callable(fn):
+                    res = fn(*args, **kwargs)
+                    fut.set_result(res)
+                else:
+                    fut.set_result(None)
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                fut.set_exception(e)
+            finally:
+                self.queue.task_done()
+
+    def _run(self):
+        while True:
+            try:
+                fn, owner, args, kwargs, fut = self.queue.get(timeout=0.01)
+            except Empty:
+                if self._closing:
+                    break
+                continue
+            except ShutDown:
+                break
+
+            # If close signal is received, finish all tasks and quit
+            if fn is None or (
+                getattr(fn, "__name__", "") == "close" and owner == "connection"
+            ):
+                fut.set_result(None)
+                self.queue.task_done()
+                self._closing = True
+                self.event.clear()
+                self.recall()  # Finish all remaining tasks
+                break
+
+            try:
+                if callable(fn):
+                    res = fn(*args, **kwargs)
+                    fut.set_result(res)
+                else:
+                    setattr(self.conn, fn, kwargs["value"])
+                    fut.set_result(None)
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                fut.set_exception(e)
+            finally:
+                self.queue.task_done()
+        # Ensure connection is closed
+        self.conn.close()
+
+    def push(self, fn, owner: str, *args, **kwargs):
+        """Push to worker"""
+        if not self.accepting.is_set() or self._closing:
+            exc = Rejection("Cannot push during shutdown")
+            exc.add_note(f"Caller: {fn}")
+            raise exc
+        fut = Future()
+        try:
+            self.queue.put((fn, owner, args, kwargs, fut))
+        except ShutDown:
+            fut.set_result(None)
+            return fut.result()
+        return fut.result()  # blocks until worker finishes
+
+    @property
+    def is_closed(self):
+        """Return true if worker is closed"""
+        return self._closing
+
+    def close(self, push=True):
+        """Close this worker"""
+        if self._closing:
+            return
+        self._closing = True
+        self.event.clear()
+        if push:
+            # Push a close signal to the queue
+            fut = Future()
+            self.queue.put((lambda: None, "connection", (), {}, fut))
+            fut.result()
+        self.worker.join()
+
+    def join(self, timeout: float = 0):
+        """Join this worker"""
+        self.worker.join(timeout)
+
+
+class WorkerCursor:
+    """Worker cursor"""
+
+    __slots__ = ("_worker", "_cursor")
+
+    def __init__(self, worker: Worker, real_cursor: Cursor):
+        self._worker: Worker = worker
+        self._cursor: Cursor = real_cursor
+
+    def __getattr__(self, item):
+        # print(self, item)
+        if item in self.__slots__:
+            return super().__getattribute__(item)
+
+        attr = getattr(self._cursor, item)
+        if callable(attr):
+            return lambda *a, **kw: self._worker.push(attr, "cursor", *a, **kw)
+        return attr
+
+
+class WorkerConnection:
+    """Worker connection"""
+
+    def __init__(self, *args, worker_type: WorkerType = "thread", **kwargs):
+        self._real: Worker = Worker(*args, worker_type=worker_type, **kwargs)
+
+    def __getattr__(self, item):
+        # print(self, item)
+        if item in ("_real", "cursor"):
+            return super().__getattribute__(item)
+
+        if item in ("join",):
+            return getattr(self._real, item)
+
+        conn = self._real.conn
+        attr = getattr(conn, item)
+        if item == "close":
+            return is_shutdown(self._real)
+
+        if callable(attr):
+            return lambda *a, **kw: self._real.push(attr, "connection", *a, **kw)
+        return attr
+
+    def cursor(self, *args, **kwargs):
+        """Return cursor object"""
+        real = self._real.push(
+            getattr(self._real.conn, "cursor"), "connection", *args, **kwargs
+        )
+        return WorkerCursor(self._real, real)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name == "_real":
+            super().__setattr__(name, value)
+            return
+        self._real.push(name, "connection", value=value)
+
+    def __enter__(self):
+        return self.cursor()
+
+    def __exit__(self, _, exc, __):
+        pass

sqlite_database-0.7.9/sqlite_database/workers/database.py

@@ -0,0 +1,62 @@
+"""Database Worker"""
+
+import warnings
+
+from sqlite_database._utils import dict_factory, NoopResource
+from sqlite_database.database import Database
+from sqlite_database.workers.connection import WorkerConnection, WorkerType
+from sqlite_database.errors import VersionError
+
+
+class DatabaseWorker(Database):
+    """Database Worker"""
+
+    def __init__(self, path: str, worker_type: WorkerType = "thread", **kwargs) -> None:
+        self._worker_type: WorkerType = worker_type
+        super().__init__(path, **kwargs)
+
+    def _create_connection(self):
+        timeout = self._kwargs.pop("timeout", 30)
+        if not isinstance(timeout, int):
+            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
+        try:
+            self._database = WorkerConnection(
+                self._path,
+                worker_type=self._worker_type,
+                timeout=timeout,
+                isolation_level=self._kwargs.pop("isolation_level", None),
+                check_same_thread=self._kwargs.pop("check_same_thread", False)
+            )
+            self._database.row_factory = dict_factory
+            self._database.execute("PRAGMA journal_mode=WAL;")
+            self._database.execute(f'PRAGMA busy_timeout={timeout * 1000};')
+        except VersionError:
+            self._database = NoopResource()
+            raise
+
+    def close(self):
+        self._database.close()
+        self._database.join() # type: ignore
+
+    def join(self):
+        """Join the worker thread/process"""
+        self._database.join() # type: ignore
+
+    def __del__(self):
+        warnings.warn(
+            (f"Instance of {self} was not properly closed." # type: ignore
+             "The process is threathened to be stalled indefinitely"
+             ),
+            ResourceWarning,
+            stacklevel=2
+        )
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self._database._real.name}>" # type: ignore

{sqlite_database-0.7.7 → sqlite_database-0.7.9/sqlite_database.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlite_database
-Version: 0.7.7
+Version: 0.7.9
 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.7 → sqlite_database-0.7.9}/sqlite_database.egg-info/SOURCES.txt

@@ -88,6 +88,9 @@ sqlite_database/models/helpers.py
 sqlite_database/models/mixin.py
 sqlite_database/models/query_builder.py
 sqlite_database/models/type_checkers.py
+sqlite_database/workers/__init__.py
+sqlite_database/workers/connection.py
+sqlite_database/workers/database.py
 tests/__init__.py
 tests/manual_test_performances.py
 tests/test_internals.py

{sqlite_database-0.7.7 → sqlite_database-0.7.9}/tests/database/table_api/test_others.py

@@ -2,9 +2,11 @@
 
 from sqlite3 import OperationalError
 from random import randint
+import sys
 
-from pytest import raises
+from pytest import mark, raises
 from sqlite_database import Database, integer
+from sqlite_database.workers import DatabaseWorker
 
 from ..setup import setup_database_fns, setup_database, count
 
@@ -63,3 +65,14 @@ def test_vacuum():
     _ = [t.delete_one({"a": randint(0, 1000)})]
     t.commit()
     db.vacuum()
+
+# @mark.skipif(sys.version_info < (3, 13), reason="Worker feature is exclusive in 3.13")
+def test_worker():
+    """Test worker"""
+
+    db = DatabaseWorker(":memory:")
+    t = db.create_table("t", [integer('a')])
+    t.insert({'a': 1})
+    t.commit()
+    assert t.select_one({'a': 1}) is not None
+    db.close()