scruby 0.26.0__py3-none-any.whl → 0.28.3__py3-none-any.whl

scruby/__init__.py

@@ -1,16 +1,11 @@
 #
-# .|'''|                        '||
-# ||                             ||
-# `|'''|, .|'', '||''| '||  ||`  ||''|, '||  ||`
-#  .   || ||     ||     ||  ||   ||  ||  `|..||
-#  |...|' `|..' .||.    `|..'|. .||..|'      ||
-#                                         ,  |'
-#                                          ''
-#
+# .dP"Y8  dP""b8 88""Yb 88   88 88""Yb Yb  dP
+# `Ybo." dP   `" 88__dP 88   88 88__dP  YbdP
+# o.`Y8b Yb      88"Yb  Y8   8P 88""Yb   8P
+# 8bodP'  YboodP 88  Yb `YbodP' 88oodP  dP
 #
 # Copyright (c) 2025 Gennady Kostyunin
-# Scruby is free software under terms of the MIT License.
-# Repository https://github.com/kebasyaty/scruby
+# SPDX-License-Identifier: MIT
 #
 """Asynchronous library for building and managing a hybrid database, by scheme of key-value.
 
@@ -30,14 +25,10 @@ requires a large number of processor threads.
 
 from __future__ import annotations
 
-__all__ = ("Scruby",)
-
-import logging
+__all__ = (
+    "settings",
+    "Scruby",
+)
 
+from scruby import settings
 from scruby.db import Scruby
-
-logging.basicConfig(
-    level=logging.INFO,
-    datefmt="%Y-%m-%d %H:%M:%S",
-    format="[%(asctime)s.%(msecs)03d] %(module)10s:%(lineno)-3d %(levelname)-7s - %(message)s",
-)

scruby/aggregation.py

@@ -1,3 +1,7 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Aggregation classes."""
 
 from __future__ import annotations

scruby/db.py

@@ -1,3 +1,7 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Creation and management of the database."""
 
 from __future__ import annotations
@@ -14,9 +18,7 @@ from typing import Any, Literal, Never, assert_never
 from anyio import Path
 from pydantic import BaseModel
 
-from scruby import constants, mixins
-
-logger = logging.getLogger(__name__)
+from scruby import mixins, settings
 
 
 class _Meta(BaseModel):
@@ -30,7 +32,7 @@ class _Meta(BaseModel):
 
 
 class Scruby(
-    mixins.Docs,
+    mixins.Keys,
     mixins.Find,
     mixins.CustomTask,
     mixins.Collection,
@@ -45,8 +47,9 @@ class Scruby(
     ) -> None:
         super().__init__()
         self._meta = _Meta
-        self._db_root = constants.DB_ROOT
-        self._hash_reduce_left = constants.HASH_REDUCE_LEFT
+        self._db_root = settings.DB_ROOT
+        self._hash_reduce_left = settings.HASH_REDUCE_LEFT
+        self._max_workers = settings.MAX_WORKERS
         # The maximum number of branches.
         match self._hash_reduce_left:
             case 0:
@@ -59,7 +62,7 @@ class Scruby(
                 self._max_branch_number = 256
             case _ as unreachable:
                 msg: str = f"{unreachable} - Unacceptable value for HASH_REDUCE_LEFT."
-                logger.critical(msg)
+                logging.critical(msg)
                 assert_never(Never(unreachable))  # pyrefly: ignore[not-callable]
 
     @classmethod
@@ -79,10 +82,10 @@ class Scruby(
         # Caching a pati for metadata.
         # The zero branch is reserved for metadata.
         branch_number: int = 0
-        branch_number_as_hash: str = f"{branch_number:08x}"[constants.HASH_REDUCE_LEFT :]
+        branch_number_as_hash: str = f"{branch_number:08x}"[settings.HASH_REDUCE_LEFT :]
         separated_hash: str = "/".join(list(branch_number_as_hash))
         meta_dir_path_tuple = (
-            constants.DB_ROOT,
+            settings.DB_ROOT,
             class_model.__name__,
             separated_hash,
         )
@@ -95,9 +98,9 @@ class Scruby(
         if not await branch_path.exists():
             await branch_path.mkdir(parents=True)
             meta = _Meta(
-                db_root=constants.DB_ROOT,
+                db_root=settings.DB_ROOT,
                 collection_name=class_model.__name__,
-                hash_reduce_left=constants.HASH_REDUCE_LEFT,
+                hash_reduce_left=settings.HASH_REDUCE_LEFT,
                 max_branch_number=instance.__dict__["_max_branch_number"],
                 counter_documents=0,
             )
@@ -123,6 +126,9 @@ class Scruby(
 
         This method is for internal use.
 
+        Args:
+            meta (_Meta): Metadata of Collection.
+
         Returns:
             None.
         """
@@ -134,6 +140,9 @@ class Scruby(
 
         This method is for internal use.
 
+        Args:
+            step (Literal[1, -1]): Number of documents added or removed.
+
         Returns:
             None.
         """
@@ -157,7 +166,7 @@ class Scruby(
         """
         if not isinstance(key, str):
             msg = "The key is not a string."
-            logger.error(msg)
+            logging.error(msg)
             raise KeyError(msg)
         # Prepare key.
         # Removes spaces at the beginning and end of a string.
@@ -166,7 +175,7 @@ class Scruby(
         # Check the key for an empty string.
         if len(prepared_key) == 0:
             msg = "The key should not be empty."
-            logger.error(msg)
+            logging.error(msg)
             raise KeyError(msg)
         # Key to crc32 sum.
         key_as_hash: str = f"{zlib.crc32(prepared_key.encode('utf-8')):08x}"[self._hash_reduce_left :]
@@ -200,5 +209,5 @@ class Scruby(
             None.
         """
         with contextlib.suppress(FileNotFoundError):
-            rmtree(constants.DB_ROOT)
+            rmtree(settings.DB_ROOT)
         return

scruby/errors.py

@@ -1,3 +1,7 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Scruby Exceptions."""
 
 from __future__ import annotations

scruby/mixins/__init__.py

@@ -1,3 +1,7 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Mixins."""
 
 from __future__ import annotations
@@ -8,7 +12,7 @@ __all__ = (
     "CustomTask",
     "Delete",
     "Find",
-    "Docs",
+    "Keys",
     "Update",
 )
 
@@ -16,6 +20,6 @@ from scruby.mixins.collection import Collection
 from scruby.mixins.count import Count
 from scruby.mixins.custom_task import CustomTask
 from scruby.mixins.delete import Delete
-from scruby.mixins.docs import Docs
 from scruby.mixins.find import Find
+from scruby.mixins.keys import Keys
 from scruby.mixins.update import Update

scruby/mixins/collection.py

@@ -1,3 +1,7 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Methods for working with collections."""
 
 from __future__ import annotations
@@ -5,16 +9,13 @@ from __future__ import annotations
 __all__ = ("Collection",)
 
 from shutil import rmtree
-from typing import TypeVar
 
 from anyio import Path, to_thread
 
-from scruby import constants
+from scruby import settings
 
-T = TypeVar("T")
 
-
-class Collection[T]:
+class Collection:
     """Methods for working with collections."""
 
     def collection_name(self) -> str:
@@ -28,7 +29,7 @@ class Collection[T]:
     @staticmethod
     async def collection_list() -> list[str]:
         """Get collection list."""
-        target_directory = Path(constants.DB_ROOT)
+        target_directory = Path(settings.DB_ROOT)
         # Get all entries in the directory
         all_entries = Path.iterdir(target_directory)
         directory_names: list[str] = [entry.name async for entry in all_entries]
@@ -44,6 +45,6 @@ class Collection[T]:
         Returns:
             None.
         """
-        target_directory = f"{constants.DB_ROOT}/{name}"
+        target_directory = f"{settings.DB_ROOT}/{name}"
         await to_thread.run_sync(rmtree, target_directory)  # pyrefly: ignore[bad-argument-type]
         return

scruby/mixins/count.py

@@ -1,3 +1,7 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Methods for counting the number of documents."""
 
 from __future__ import annotations
@@ -6,12 +10,10 @@ __all__ = ("Count",)
 
 import concurrent.futures
 from collections.abc import Callable
-from typing import TypeVar
+from typing import Any
 
-T = TypeVar("T")
 
-
-class Count[T]:
+class Count:
     """Methods for counting the number of documents."""
 
     async def estimated_document_count(self) -> int:
@@ -26,30 +28,27 @@ class Count[T]:
     async def count_documents(
         self,
         filter_fn: Callable,
-        max_workers: int | None = None,
     ) -> int:
         """Count the number of documents a matching the filter in this collection.
 
         The search is based on the effect of a quantum loop.
         The search effectiveness depends on the number of processor threads.
-        Ideally, hundreds and even thousands of threads are required.
 
         Args:
             filter_fn: A function that execute the conditions of filtering.
-            max_workers: The maximum number of processes that can be used to
-                         execute the given calls. If None or not given then as many
-                         worker processes will be created as the machine has processors.
 
         Returns:
             The number of documents.
         """
-        branch_numbers: range = range(1, self._max_branch_number)
+        # Variable initialization
         search_task_fn: Callable = self._task_find
+        branch_numbers: range = range(1, self._max_branch_number)
         hash_reduce_left: int = self._hash_reduce_left
         db_root: str = self._db_root
-        class_model: T = self._class_model
+        class_model: Any = self._class_model
         counter: int = 0
-        with concurrent.futures.ThreadPoolExecutor(max_workers) as executor:
+        # Run quantum loop
+        with concurrent.futures.ThreadPoolExecutor(self._max_workers) as executor:
             for branch_number in branch_numbers:
                 future = executor.submit(
                     search_task_fn,

scruby/mixins/custom_task.py

@@ -1,22 +1,21 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Quantum methods for running custom tasks."""
 
 from __future__ import annotations
 
 __all__ = ("CustomTask",)
 
-import logging
 from collections.abc import Callable
-from typing import Any, TypeVar
+from typing import Any
 
 import orjson
 from anyio import Path
 
-logger = logging.getLogger(__name__)
 
-T = TypeVar("T")
-
-
-class CustomTask[T]:
+class CustomTask:
     """Quantum methods for running custom tasks."""
 
     @staticmethod
@@ -24,7 +23,7 @@ class CustomTask[T]:
         branch_number: int,
         hash_reduce_left: int,
         db_root: str,
-        class_model: T,
+        class_model: Any,
     ) -> list[Any]:
         """Get documents for custom task.
 
@@ -56,7 +55,6 @@ class CustomTask[T]:
 
         This method running a task created on the basis of a quantum loop.
         Effectiveness running task depends on the number of processor threads.
-        Ideally, hundreds and even thousands of threads are required.
 
         Args:
             custom_task_fn: A function that execute the custom task.

scruby/mixins/delete.py

@@ -1,3 +1,7 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Methods for deleting documents."""
 
 from __future__ import annotations
@@ -5,19 +9,14 @@ from __future__ import annotations
 __all__ = ("Delete",)
 
 import concurrent.futures
-import logging
 from collections.abc import Callable
-from typing import TypeVar
+from typing import Any
 
 import orjson
 from anyio import Path
 
-logger = logging.getLogger(__name__)
 
-T = TypeVar("T")
-
-
-class Delete[T]:
+class Delete:
     """Methods for deleting documents."""
 
     @staticmethod
@@ -26,7 +25,7 @@ class Delete[T]:
         filter_fn: Callable,
         hash_reduce_left: int,
         db_root: str,
-        class_model: T,
+        class_model: Any,
     ) -> int:
         """Task for find and delete documents.
 
@@ -62,30 +61,27 @@ class Delete[T]:
     async def delete_many(
         self,
         filter_fn: Callable,
-        max_workers: int | None = None,
     ) -> int:
         """Delete one or more documents matching the filter.
 
         The search is based on the effect of a quantum loop.
         The search effectiveness depends on the number of processor threads.
-        Ideally, hundreds and even thousands of threads are required.
 
         Args:
             filter_fn: A function that execute the conditions of filtering.
-            max_workers: The maximum number of processes that can be used to
-                         execute the given calls. If None or not given then as many
-                         worker processes will be created as the machine has processors.
 
         Returns:
             The number of deleted documents.
         """
-        branch_numbers: range = range(1, self._max_branch_number)
+        # Variable initialization
         search_task_fn: Callable = self._task_delete
+        branch_numbers: range = range(1, self._max_branch_number)
         hash_reduce_left: int = self._hash_reduce_left
         db_root: str = self._db_root
-        class_model: T = self._class_model
+        class_model: Any = self._class_model
         counter: int = 0
-        with concurrent.futures.ThreadPoolExecutor(max_workers) as executor:
+        # Run quantum loop
+        with concurrent.futures.ThreadPoolExecutor(self._max_workers) as executor:
             for branch_number in branch_numbers:
                 future = executor.submit(
                     search_task_fn,

scruby/mixins/find.py

@@ -1,3 +1,7 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Quantum methods for searching documents."""
 
 from __future__ import annotations
@@ -5,19 +9,14 @@ from __future__ import annotations
 __all__ = ("Find",)
 
 import concurrent.futures
-import logging
 from collections.abc import Callable
-from typing import TypeVar
+from typing import Any
 
 import orjson
 from anyio import Path
 
-logger = logging.getLogger(__name__)
 
-T = TypeVar("T")
-
-
-class Find[T]:
+class Find:
     """Quantum methods for searching documents."""
 
     @staticmethod
@@ -26,8 +25,8 @@ class Find[T]:
         filter_fn: Callable,
         hash_reduce_left: str,
         db_root: str,
-        class_model: T,
-    ) -> list[T] | None:
+        class_model: Any,
+    ) -> list[Any] | None:
         """Task for find documents.
 
         This method is for internal use.
@@ -35,6 +34,7 @@ class Find[T]:
         Returns:
             List of documents or None.
         """
+        # Variable initialization
         branch_number_as_hash: str = f"{branch_number:08x}"[hash_reduce_left:]
         separated_hash: str = "/".join(list(branch_number_as_hash))
         leaf_path: Path = Path(
@@ -45,7 +45,7 @@ class Find[T]:
                 "leaf.json",
             ),
         )
-        docs: list[T] = []
+        docs: list[Any] = []
         if await leaf_path.exists():
             data_json: bytes = await leaf_path.read_bytes()
             data: dict[str, str] = orjson.loads(data_json) or {}
@@ -58,29 +58,26 @@ class Find[T]:
     async def find_one(
         self,
         filter_fn: Callable,
-        max_workers: int | None = None,
-    ) -> T | None:
-        """Finds a single document matching the filter.
+    ) -> Any | None:
+        """Find one document matching the filter.
 
         The search is based on the effect of a quantum loop.
         The search effectiveness depends on the number of processor threads.
-        Ideally, hundreds and even thousands of threads are required.
 
         Args:
-            filter_fn: A function that execute the conditions of filtering.
-            max_workers: The maximum number of processes that can be used to
-                         execute the given calls. If None or not given then as many
-                         worker processes will be created as the machine has processors.
+            filter_fn (Callable): A function that execute the conditions of filtering.
 
         Returns:
             Document or None.
         """
-        branch_numbers: range = range(1, self._max_branch_number)
+        # Variable initialization
         search_task_fn: Callable = self._task_find
+        branch_numbers: range = range(1, self._max_branch_number)
         hash_reduce_left: int = self._hash_reduce_left
         db_root: str = self._db_root
-        class_model: T = self._class_model
-        with concurrent.futures.ThreadPoolExecutor(max_workers) as executor:
+        class_model: Any = self._class_model
+        # Run quantum loop
+        with concurrent.futures.ThreadPoolExecutor(self._max_workers) as executor:
             for branch_number in branch_numbers:
                 future = executor.submit(
                     search_task_fn,
@@ -97,36 +94,40 @@ class Find[T]:
 
     async def find_many(
         self,
-        filter_fn: Callable,
+        filter_fn: Callable = lambda _: True,
         limit_docs: int = 1000,
-        max_workers: int | None = None,
-    ) -> list[T] | None:
-        """Finds one or more documents matching the filter.
+        page_number: int = 1,
+    ) -> list[Any] | None:
+        """Find many documents matching the filter.
 
         The search is based on the effect of a quantum loop.
         The search effectiveness depends on the number of processor threads.
-        Ideally, hundreds and even thousands of threads are required.
 
         Args:
-            filter_fn: A function that execute the conditions of filtering.
-            limit_docs: Limiting the number of documents. By default = 1000.
-            max_workers: The maximum number of processes that can be used to
-                         execute the given calls. If None or not given then as many
-                         worker processes will be created as the machine has processors.
+            filter_fn (Callable): A function that execute the conditions of filtering.
+                                  By default it searches for all documents.
+            limit_docs (int): Limiting the number of documents. By default = 1000.
+            page_number (int): For pagination output. By default = 1.
+                               Number of documents per page = limit_docs.
 
         Returns:
             List of documents or None.
         """
-        branch_numbers: range = range(1, self._max_branch_number)
+        # The `page_number` parameter must not be less than one
+        assert page_number > 0, "`find_many` => The `page_number` parameter must not be less than one."
+        # Variable initialization
         search_task_fn: Callable = self._task_find
+        branch_numbers: range = range(1, self._max_branch_number)
         hash_reduce_left: int = self._hash_reduce_left
         db_root: str = self._db_root
-        class_model: T = self._class_model
+        class_model: Any = self._class_model
         counter: int = 0
-        result: list[T] = []
-        with concurrent.futures.ThreadPoolExecutor(max_workers) as executor:
+        number_docs_skippe: int = limit_docs * (page_number - 1) if page_number > 1 else 0
+        result: list[Any] = []
+        # Run quantum loop
+        with concurrent.futures.ThreadPoolExecutor(self._max_workers) as executor:
             for branch_number in branch_numbers:
-                if counter >= limit_docs:
+                if number_docs_skippe == 0 and counter >= limit_docs:
                     return result[:limit_docs]
                 future = executor.submit(
                     search_task_fn,
@@ -139,8 +140,11 @@ class Find[T]:
                 docs = await future.result()
                 if docs is not None:
                     for doc in docs:
-                        if counter >= limit_docs:
-                            return result[:limit_docs]
-                        result.append(doc)
-                        counter += 1
+                        if number_docs_skippe == 0:
+                            if counter >= limit_docs:
+                                return result[:limit_docs]
+                            result.append(doc)
+                            counter += 1
+                        else:
+                            number_docs_skippe -= 1
         return result or None

scruby/mixins/{docs.py → keys.py}

@@ -1,8 +1,12 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Methods for working with keys."""
 
 from __future__ import annotations
 
-__all__ = ("Docs",)
+__all__ = ("Keys",)
 
 import logging
 from typing import Any
@@ -14,11 +18,9 @@ from scruby.errors import (
     KeyNotExistsError,
 )
 
-logger = logging.getLogger(__name__)
 
-
-class Docs:
-    """Methods for working with document."""
+class Keys:
+    """Methods for working with keys."""
 
     async def add_doc(self, doc: Any) -> None:
         """Asynchronous method for adding document to collection.
@@ -36,7 +38,7 @@ class Docs:
             msg = (
                 f"(add_doc) Parameter `doc` => Model `{doc_class_name}` does not match collection `{collection_name}`!"
             )
-            logger.error(msg)
+            logging.error(msg)
             raise TypeError(msg)
         # The path to cell of collection.
         leaf_path, prepared_key = await self._get_leaf_path(doc.key)
@@ -53,7 +55,7 @@ class Docs:
                 await leaf_path.write_bytes(orjson.dumps(data))
             else:
                 err = KeyAlreadyExistsError()
-                logger.error(err.message)
+                logging.error(err.message)
                 raise err
         else:
             # Add new document to a blank leaf.
@@ -77,7 +79,7 @@ class Docs:
                 f"(update_doc) Parameter `doc` => Model `{doc_class_name}` "
                 f"does not match collection `{collection_name}`!"
             )
-            logger.error(msg)
+            logging.error(msg)
             raise TypeError(msg)
         # The path to cell of collection.
         leaf_path, prepared_key = await self._get_leaf_path(doc.key)
@@ -93,10 +95,10 @@ class Docs:
                 await leaf_path.write_bytes(orjson.dumps(data))
             except KeyError:
                 err = KeyNotExistsError()
-                logger.error(err.message)
+                logging.error(err.message)
                 raise err from None
         else:
-            logger.error("The key not exists.")
+            logging.error("The key not exists.")
             raise KeyError()
 
     async def get_key(self, key: str) -> Any:
@@ -117,7 +119,7 @@ class Docs:
             obj: Any = self._class_model.model_validate_json(data[prepared_key])
             return obj
         msg: str = "`get_key` - The unacceptable key value."
-        logger.error(msg)
+        logging.error(msg)
         raise KeyError()
 
     async def has_key(self, key: str) -> bool:
@@ -162,5 +164,5 @@ class Docs:
             await self._counter_documents(-1)
             return
         msg: str = "`delete_key` - The unacceptable key value."
-        logger.error(msg)
+        logging.error(msg)
         raise KeyError()

scruby/mixins/update.py

@@ -1,3 +1,7 @@
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
 """Methods for updating documents."""
 
 from __future__ import annotations
@@ -5,19 +9,14 @@ from __future__ import annotations
 __all__ = ("Update",)
 
 import concurrent.futures
-import logging
 from collections.abc import Callable
-from typing import Any, TypeVar
+from typing import Any
 
 import orjson
 from anyio import Path
 
-logger = logging.getLogger(__name__)
 
-T = TypeVar("T")
-
-
-class Update[T]:
+class Update:
     """Methods for updating documents."""
 
     @staticmethod
@@ -26,7 +25,7 @@ class Update[T]:
         filter_fn: Callable,
         hash_reduce_left: str,
         db_root: str,
-        class_model: T,
+        class_model: Any,
         new_data: dict[str, Any],
     ) -> int:
         """Task for find documents.
@@ -65,31 +64,28 @@ class Update[T]:
         self,
         filter_fn: Callable,
         new_data: dict[str, Any],
-        max_workers: int | None = None,
     ) -> int:
         """Updates one or more documents matching the filter.
 
         The search is based on the effect of a quantum loop.
         The search effectiveness depends on the number of processor threads.
-        Ideally, hundreds and even thousands of threads are required.
 
         Args:
             filter_fn: A function that execute the conditions of filtering.
             new_data: New data for the fields that need to be updated.
-            max_workers: The maximum number of processes that can be used to
-                         execute the given calls. If None or not given then as many
-                         worker processes will be created as the machine has processors.
 
         Returns:
             The number of updated documents.
         """
-        branch_numbers: range = range(1, self._max_branch_number)
+        # Variable initialization
         update_task_fn: Callable = self._task_update
+        branch_numbers: range = range(1, self._max_branch_number)
         hash_reduce_left: int = self._hash_reduce_left
         db_root: str = self._db_root
-        class_model: T = self._class_model
+        class_model: Any = self._class_model
         counter: int = 0
-        with concurrent.futures.ThreadPoolExecutor(max_workers) as executor:
+        # Run quantum loop
+        with concurrent.futures.ThreadPoolExecutor(self._max_workers) as executor:
             for branch_number in branch_numbers:
                 future = executor.submit(
                     update_task_fn,

scruby/{constants.py → settings.py}

@@ -1,6 +1,10 @@
-"""Constant variables.
+# Scruby - Asynchronous library for building and managing a hybrid database, by scheme of key-value.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+#
+"""Database settings.
 
-The module contains the following variables:
+The module contains the following parameters:
 
 - `DB_ROOT` - Path to root directory of database. `By default = "ScrubyDB" (in root of project)`.
 - `HASH_REDUCE_LEFT` - The length of the hash reduction on the left side.
@@ -8,6 +12,7 @@ The module contains the following variables:
     - `2` - 16777216 branches in collection.
     - `4` - 65536 branches in collection.
     - `6` - 256 branches in collection (by default).
+- `MAX_WORKERS` - The maximum number of processes that can be used `By default = None`.
 """
 
 from __future__ import annotations
@@ -15,6 +20,7 @@ from __future__ import annotations
 __all__ = (
     "DB_ROOT",
     "HASH_REDUCE_LEFT",
+    "MAX_WORKERS",
 )
 
 from typing import Literal
@@ -31,3 +37,8 @@ DB_ROOT: str = "ScrubyDB"
 # Number of branches is number of requests to the hard disk during quantum operations.
 # Quantum operations: find_one, find_many, count_documents, delete_many, run_custom_task.
 HASH_REDUCE_LEFT: Literal[0, 2, 4, 6] = 6
+
+# The maximum number of processes that can be used to execute the given calls.
+# If None, then as many worker processes will be
+# created as the machine has processors.
+MAX_WORKERS: int | None = None

{scruby-0.26.0.dist-info → scruby-0.28.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scruby
-Version: 0.26.0
+Version: 0.28.3
 Summary: Asynchronous library for building and managing a hybrid database, by scheme of key-value.
 Project-URL: Homepage, https://kebasyaty.github.io/scruby/
 Project-URL: Repository, https://github.com/kebasyaty/scruby
@@ -17,6 +17,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.12
@@ -110,10 +111,11 @@ import datetime
 from typing import Annotated
 from pydantic import BaseModel, EmailStr, Field
 from pydantic_extra_types.phone_numbers import PhoneNumber, PhoneNumberValidator
-from scruby import Scruby, constants
+from scruby import Scruby, settings
 
-constants.DB_ROOT = "ScrubyDB"  # By default = "ScrubyDB"
-constants.HASH_REDUCE_LEFT = 6  # By default = 6
+settings.DB_ROOT = "ScrubyDB"  # By default = "ScrubyDB"
+settings.HASH_REDUCE_LEFT = 6  # By default = 6
+settings.MAX_WORKERS = None  # By default = None
 
 class User(BaseModel):
     """User model."""
@@ -132,7 +134,7 @@ class User(BaseModel):
 
 async def main() -> None:
     """Example."""
-    # Get collection of `User`.
+    # Get collection `User`.
     user_coll = await Scruby.collection(User)
 
     user = User(
@@ -167,22 +169,22 @@ if __name__ == "__main__":
 ```
 
 ```python
-"""Find a single document matching the filter.
+"""Find one document matching the filter.
 
 The search is based on the effect of a quantum loop.
 The search effectiveness depends on the number of processor threads.
-Ideally, hundreds and even thousands of threads are required.
 """
 
 import anyio
 import datetime
 from typing import Annotated
 from pydantic import BaseModel, Field
-from scruby import Scruby, constants
+from scruby import Scruby, settings
 from pprint import pprint as pp
 
-constants.DB_ROOT = "ScrubyDB"  # By default = "ScrubyDB"
-constants.HASH_REDUCE_LEFT = 6  # By default = 6
+settings.DB_ROOT = "ScrubyDB"  # By default = "ScrubyDB"
+settings.HASH_REDUCE_LEFT = 6  # By default = 6
+settings.MAX_WORKERS = None  # By default = None
 
 
 class Phone(BaseModel):
@@ -201,7 +203,7 @@ class Phone(BaseModel):
 
 async def main() -> None:
     """Example."""
-    # Get collection of `Phone`.
+    # Get collection `Phone`.
     phone_coll = await Scruby.collection(Phone)
 
     # Create phone.
@@ -243,22 +245,22 @@ if __name__ == "__main__":
 ```
 
 ```python
-"""Find one or more documents matching the filter.
+"""Find many documents matching the filter.
 
 The search is based on the effect of a quantum loop.
 The search effectiveness depends on the number of processor threads.
-Ideally, hundreds and even thousands of threads are required.
 """
 
 import anyio
 import datetime
 from typing import Annotated
 from pydantic import BaseModel, Field
-from scruby import Scruby, constants
+from scruby import Scruby, settings
 from pprint import pprint as pp
 
-constants.DB_ROOT = "ScrubyDB"  # By default = "ScrubyDB"
-constants.HASH_REDUCE_LEFT = 6  # By default = 6
+settings.DB_ROOT = "ScrubyDB"  # By default = "ScrubyDB"
+settings.HASH_REDUCE_LEFT = 6  # By default = 6
+settings.MAX_WORKERS = None  # By default = None
 
 
 class Car(BaseModel):
@@ -277,11 +279,11 @@ class Car(BaseModel):
 
 async def main() -> None:
     """Example."""
-    # Get collection of `Car`.
+    # Get collection `Car`.
     car_coll = await Scruby.collection(Car)
 
     # Create cars.
-    for name in range(1, 10):
+    for num in range(1, 10):
         car = Car(
             brand="Mazda",
             model=f"EZ-6 {num}",
@@ -299,9 +301,23 @@ async def main() -> None:
     else:
         print("No cars!")
 
-    # Get collection list.
-    collection_list = await Scruby.collection_list()
-    print(collection_list)  # ["Car"]
+    # Find all cars.
+    car_list: list[Car] | None = await car_coll.find_many()
+    if car_list is not None:
+        pp(car_list)
+    else:
+        print("No cars!")
+
+    # For pagination output.
+    car_list: list[Car] | None = await car_coll.find_many(
+        filter_fn=lambda doc: doc.brand == "Mazda",
+        limit_docs=5,
+        page_number=2,
+    )
+    if car_list is not None:
+        pp(car_list)
+    else:
+        print("No cars!")
 
     # Full database deletion.
     # Hint: The main purpose is tests.

scruby-0.28.3.dist-info/RECORD

@@ -0,0 +1,18 @@
+scruby/__init__.py,sha256=bw2Le5ULYlf2nFQT_617rmEumu66Ll-QCLCxqDFERWw,1014
+scruby/aggregation.py,sha256=bd70J1Xye6faNHD8LS3lVQoHWKtPdPV_cqT_i7oui38,3491
+scruby/db.py,sha256=djo4JkfuKCcV3jRbd2L3mIwENS3ptqJBt7SlAuiRhGY,6794
+scruby/errors.py,sha256=D0jisudUsZk9iXp4nRSymaSMwyqHPVshsSlxx4HDVVk,1297
+scruby/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scruby/settings.py,sha256=_uVdZIGWoi6q9zcu0c2PS51OBEBNASRRrxfzaF7Nwy0,1580
+scruby/mixins/__init__.py,sha256=XPMjJvOZN7dLpTE1FfGMBGQ_0421HXug-0rWKMU5fRQ,627
+scruby/mixins/collection.py,sha256=coF-IOhicV_EihDwnYf6SW5Mfi3nOFR0gAhCc619NmI,1382
+scruby/mixins/count.py,sha256=PGzRtgLvseQnHg6wt-A81s30pnsdY1d8cr-EQRnbfyU,2050
+scruby/mixins/custom_task.py,sha256=ZhvCDiYnJ8BTIWlnRu6cTH-9G9o7dHSixjMIsxAtDpw,2316
+scruby/mixins/delete.py,sha256=B2loiowj8ToO0euumDRxpHUVrLQx0iTcRys0jszn-rA,3046
+scruby/mixins/find.py,sha256=gnHjnm0MZbzMHmWOBUJbMm8LZFBqdJ6yWA6Pxfap51Q,5340
+scruby/mixins/keys.py,sha256=OUByWbHfNVWJVkUrhCsJZdVqf0zez_an6Gti2n5iKnM,5671
+scruby/mixins/update.py,sha256=YkUiz1gcVtNXdgf7Mmda-0g3vJm3jL09v-msGy2tAWg,3229
+scruby-0.28.3.dist-info/METADATA,sha256=DoDzTEj_wrZu3EfAhBcKBtCfbr9pb74FS3spyDpFfzY,10849
+scruby-0.28.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+scruby-0.28.3.dist-info/licenses/LICENSE,sha256=mS0Wz0yGNB63gEcWEnuIb_lldDYV0sjRaO-o_GL6CWE,1074
+scruby-0.28.3.dist-info/RECORD,,

scruby-0.26.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-scruby/__init__.py,sha256=iYjvi002DeRh-U_ND2cCOHlbX2xwxN8IIhsposeotNw,1504
-scruby/aggregation.py,sha256=SYGcnMy2eq9vJb-pW3xR9LLAQIQ55TK-LGW_yKQ-7sU,3318
-scruby/constants.py,sha256=KInSZ_4dsQNXilrs7DvtQXevKEYibnNzl69a7XiWG4k,1099
-scruby/db.py,sha256=06GjnhN9lKvZo585nxKFd4z8Ox858Ep08c7eCbMA99k,6462
-scruby/errors.py,sha256=aj1zQlfxGwZC-bZZ07DRX2vHx31SpyWPqXHMpQ9kRVY,1124
-scruby/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scruby/mixins/__init__.py,sha256=w1Be13FHAGSkdRfXcmoZ-eDn5Q8cFsPRAV7k1tXkIwY,454
-scruby/mixins/collection.py,sha256=kqUgzJbgG9pTZhlP7OD5DsOaArRzu0fl6fVibLAdNtk,1260
-scruby/mixins/count.py,sha256=Wcn6CeWrYSgsTTmYQ4J-CEiM4630rUSwRP9iKwbCl6c,2193
-scruby/mixins/custom_task.py,sha256=DL-pQZninz7CJUyRYlVV7SNPC60qMD3ZQyMLnC3zVTM,2294
-scruby/mixins/delete.py,sha256=BmfQH68iX7kzC20w16xzFcLO3uLxYKdNyqZqIbXb1M0,3240
-scruby/mixins/docs.py,sha256=UHawXUjIkDBtik6MIQwbPF3DZKSOG8WI4Da9_i_-9R4,5533
-scruby/mixins/find.py,sha256=va1hTm6Poua7_TMcZW2iqI-xmL1HcCUOx8pkKvTvu6U,5063
-scruby/mixins/update.py,sha256=A9V4PjA3INnqLTGoBxIvC8y8Wo-nLxlFejkPUhsebzQ,3428
-scruby-0.26.0.dist-info/METADATA,sha256=CluDLzRgB952ZDbbxdsXuHGE598BzIiF5eYXpGaNdj4,10483
-scruby-0.26.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-scruby-0.26.0.dist-info/licenses/LICENSE,sha256=mS0Wz0yGNB63gEcWEnuIb_lldDYV0sjRaO-o_GL6CWE,1074
-scruby-0.26.0.dist-info/RECORD,,