scruby 0.10.3__py3-none-any.whl → 0.11.0__py3-none-any.whl

scruby/constants.py

@@ -3,7 +3,7 @@
 The module contains the following variables:
 
 - `DB_ROOT` - Path to root directory of database. `By default = "ScrubyDB"` (*in root of project*).
-- `LENGTH_REDUCTION_HASH` - The length of the hash reduction on the left side.
+- `HASH_REDUCE_LEFT` - The length of the hash reduction on the left side.
     - `0` - 4294967296 branches in collection (by default).
     - `2` - 16777216 branches in collectionю
     - `4` - 65536 branches in collectionю
@@ -14,7 +14,7 @@ from __future__ import annotations
 
 __all__ = (
     "DB_ROOT",
-    "LENGTH_REDUCTION_HASH",
+    "HASH_REDUCE_LEFT",
 )
 
 from typing import Literal
@@ -28,4 +28,4 @@ DB_ROOT: str = "ScrubyDB"
 # 2 = 16777216 branches in collectionю
 # 4 = 65536 branches in collectionю
 # 6 = 256 branches in collection (main purpose is tests).
-LENGTH_REDUCTION_HASH: Literal[0, 2, 4, 6] = 0
+HASH_REDUCE_LEFT: Literal[0, 2, 4, 6] = 0

scruby/db.py

@@ -11,7 +11,7 @@ import zlib
 from collections.abc import Callable
 from pathlib import Path as SyncPath
 from shutil import rmtree
-from typing import Any, Literal, Never, TypeVar, assert_never
+from typing import Any, Never, TypeVar, assert_never
 
 import orjson
 from anyio import Path, to_thread
@@ -27,9 +27,6 @@ T = TypeVar("T")
 class _Meta(BaseModel):
     """Metadata of Collection."""
 
-    db_root: str
-    model_name: str
-    length_reduction_hash: int
     counter_documents: int
 
 
@@ -47,19 +44,19 @@ class Scruby[T]:
         self.__meta = _Meta
         self.__class_model = class_model
         self.__db_root = constants.DB_ROOT
-        self.__length_reduction_hash = constants.LENGTH_REDUCTION_HASH
+        self.__hash_reduce_left = constants.HASH_REDUCE_LEFT
         # The maximum number of keys.
-        match self.__length_reduction_hash:
+        match self.__hash_reduce_left:
             case 0:
-                self.__max_num_keys = 4294967296
+                self.__max_branch_number = 4294967296
             case 2:
-                self.__max_num_keys = 16777216
+                self.__max_branch_number = 16777216
             case 4:
-                self.__max_num_keys = 65536
+                self.__max_branch_number = 65536
             case 6:
-                self.__max_num_keys = 256
+                self.__max_branch_number = 256
             case _ as unreachable:
-                msg: str = f"{unreachable} - Unacceptable value for LENGTH_REDUCTION_HASH."
+                msg: str = f"{unreachable} - Unacceptable value for HASH_REDUCE_LEFT."
                 logger.critical(msg)
                 assert_never(Never(unreachable))
         # 1.Create metadata if absent.
@@ -71,8 +68,8 @@ class Scruby[T]:
 
         This method is for internal use.
         """
-        key: int = 0
-        key_as_hash: str = f"{key:08x}"[self.__length_reduction_hash :]
+        branch_number: int = 0
+        key_as_hash: str = f"{branch_number:08x}"[self.__hash_reduce_left :]
         separated_hash: str = "/".join(list(key_as_hash))
         branch_path = SyncPath(
             *(
@@ -84,9 +81,6 @@ class Scruby[T]:
         if not branch_path.exists():
             branch_path.mkdir(parents=True)
             meta = _Meta(
-                db_root=self.__db_root,
-                model_name=self.__class_model.__name__,
-                length_reduction_hash=self.__length_reduction_hash,
                 counter_documents=0,
             )
             meta_json = meta.model_dump_json()
@@ -98,9 +92,9 @@ class Scruby[T]:
 
         This method is for internal use.
         """
-        key: int = 0
-        key_as_hash: str = f"{key:08x}"[self.__length_reduction_hash :]
-        separated_hash: str = "/".join(list(key_as_hash))
+        branch_number: int = 0
+        branch_number_as_hash: str = f"{branch_number:08x}"[self.__hash_reduce_left :]
+        separated_hash: str = "/".join(list(branch_number_as_hash))
         return Path(
             *(
                 self.__db_root,
@@ -129,16 +123,43 @@ class Scruby[T]:
         meta_json = meta.model_dump_json()
         await meta_path.write_text(meta_json, "utf-8")
 
-    async def _counter_documents(self, step: Literal[1, -1]) -> None:
+    async def _counter_documents(self, number: int) -> None:
+        """Asynchronous method for management of documents in metadata of collection.
+
+        This method is for internal use.
+        """
+        meta_path = await self._get_meta_path()
+        meta_json = await meta_path.read_text("utf-8")
+        meta: _Meta = self.__meta.model_validate_json(meta_json)
+        meta.counter_documents += number
+        if meta.counter_documents < 0:
+            meta.counter_documents = 0
+        meta_json = meta.model_dump_json()
+        await meta_path.write_text(meta_json, "utf-8")
+
+    def _sync_counter_documents(self, number: int) -> None:
         """Management of documents in metadata of collection.
 
         This method is for internal use.
         """
-        meta = await self._get_meta()
-        meta.counter_documents += step
+        branch_number: int = 0
+        branch_number_as_hash: str = f"{branch_number:08x}"[self.__hash_reduce_left :]
+        separated_hash: str = "/".join(list(branch_number_as_hash))
+        meta_path = SyncPath(
+            *(
+                self.__db_root,
+                self.__class_model.__name__,
+                separated_hash,
+                "meta.json",
+            ),
+        )
+        meta_json = meta_path.read_text("utf-8")
+        meta: _Meta = self.__meta.model_validate_json(meta_json)
+        meta.counter_documents += number
         if meta.counter_documents < 0:
             meta.counter_documents = 0
-        await self._set_meta(meta)
+        meta_json = meta.model_dump_json()
+        meta_path.write_text(meta_json, "utf-8")
 
     async def _get_leaf_path(self, key: str) -> Path:
         """Asynchronous method for getting path to collection cell by key.
@@ -155,7 +176,7 @@ class Scruby[T]:
             logger.error("The key should not be empty.")
             raise KeyError("The key should not be empty.")
         # Key to crc32 sum.
-        key_as_hash: str = f"{zlib.crc32(key.encode('utf-8')):08x}"[self.__length_reduction_hash :]
+        key_as_hash: str = f"{zlib.crc32(key.encode('utf-8')):08x}"[self.__hash_reduce_left :]
         # Convert crc32 sum in the segment of path.
         separated_hash: str = "/".join(list(key_as_hash))
         # The path of the branch to the database.
@@ -273,18 +294,18 @@ class Scruby[T]:
 
     @staticmethod
     def _task_find(
-        key: int,
+        branch_number: int,
         filter_fn: Callable,
-        length_reduction_hash: str,
+        hash_reduce_left: str,
         db_root: str,
         class_model: T,
     ) -> dict[str, Any] | None:
-        """Task for searching for documents.
+        """Task for find documents.
 
         This method is for internal use.
         """
-        key_as_hash: str = f"{key:08x}"[length_reduction_hash:]
-        separated_hash: str = "/".join(list(key_as_hash))
+        branch_number_as_hash: str = f"{branch_number:08x}"[hash_reduce_left:]
+        separated_hash: str = "/".join(list(branch_number_as_hash))
         leaf_path: SyncPath = SyncPath(
             *(
                 db_root,
@@ -308,7 +329,7 @@ class Scruby[T]:
         max_workers: int | None = None,
         timeout: float | None = None,
     ) -> T | None:
-        """Find a single document matching the filter.
+        """Finds a single 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.
@@ -322,18 +343,18 @@ class Scruby[T]:
             timeout: The number of seconds to wait for the result if the future isn't done.
                      If None, then there is no limit on the wait time.
         """
-        keys: range = range(1, self.__max_num_keys)
+        branch_numbers: range = range(1, self.__max_branch_number)
         search_task_fn: Callable = self._task_find
-        length_reduction_hash: int = self.__length_reduction_hash
+        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:
-            for key in keys:
+            for branch_number in branch_numbers:
                 future = executor.submit(
                     search_task_fn,
-                    key,
+                    branch_number,
                     filter_fn,
-                    length_reduction_hash,
+                    hash_reduce_left,
                     db_root,
                     class_model,
                 )
@@ -342,14 +363,14 @@ class Scruby[T]:
                     return doc
         return None
 
-    def find(
+    def find_many(
         self,
         filter_fn: Callable,
         db_query_docs_limit: int = 1000,
         max_workers: int | None = None,
         timeout: float | None = None,
     ) -> list[T] | None:
-        """Find one or more documents matching the filter.
+        """Finds 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.
@@ -364,22 +385,22 @@ class Scruby[T]:
             timeout: The number of seconds to wait for the result if the future isn't done.
                      If None, then there is no limit on the wait time.
         """
-        keys: range = range(1, self.__max_num_keys)
+        branch_numbers: range = range(1, self.__max_branch_number)
         search_task_fn: Callable = self._task_find
-        length_reduction_hash: int = self.__length_reduction_hash
+        hash_reduce_left: int = self.__hash_reduce_left
         db_root: str = self.__db_root
         class_model: T = self.__class_model
         counter: int = 0
         with concurrent.futures.ThreadPoolExecutor(max_workers) as executor:
             results = []
-            for key in keys:
+            for branch_number in branch_numbers:
                 if counter == db_query_docs_limit:
                     break
                 future = executor.submit(
                     search_task_fn,
-                    key,
+                    branch_number,
                     filter_fn,
-                    length_reduction_hash,
+                    hash_reduce_left,
                     db_root,
                     class_model,
                 )
@@ -422,22 +443,99 @@ class Scruby[T]:
             timeout: The number of seconds to wait for the result if the future isn't done.
                      If None, then there is no limit on the wait time.
         """
-        keys: range = range(1, self.__max_num_keys)
+        branch_numbers: range = range(1, self.__max_branch_number)
         search_task_fn: Callable = self._task_find
-        length_reduction_hash: int = self.__length_reduction_hash
+        hash_reduce_left: int = self.__hash_reduce_left
         db_root: str = self.__db_root
         class_model: T = self.__class_model
         counter: int = 0
         with concurrent.futures.ThreadPoolExecutor(max_workers) as executor:
-            for key in keys:
+            for branch_number in branch_numbers:
                 future = executor.submit(
                     search_task_fn,
-                    key,
+                    branch_number,
                     filter_fn,
-                    length_reduction_hash,
+                    hash_reduce_left,
                     db_root,
                     class_model,
                 )
                 if future.result(timeout) is not None:
                     counter += 1
         return counter
+
+    @staticmethod
+    def _task_delete(
+        branch_number: int,
+        filter_fn: Callable,
+        hash_reduce_left: str,
+        db_root: str,
+        class_model: T,
+    ) -> int:
+        """Task for find and delete documents.
+
+        This method is for internal use.
+        """
+        branch_number_as_hash: str = f"{branch_number:08x}"[hash_reduce_left:]
+        separated_hash: str = "/".join(list(branch_number_as_hash))
+        leaf_path: SyncPath = SyncPath(
+            *(
+                db_root,
+                class_model.__name__,
+                separated_hash,
+                "leaf.json",
+            ),
+        )
+        counter: int = 0
+        if leaf_path.exists():
+            data_json: bytes = leaf_path.read_bytes()
+            data: dict[str, str] = orjson.loads(data_json) or {}
+            new_data: dict[str, str] = {}
+            for key, val in data.items():
+                doc = class_model.model_validate_json(val)
+                if filter_fn(doc):
+                    counter -= 1
+                else:
+                    new_data[key] = val
+            leaf_path.write_bytes(orjson.dumps(new_data))
+        return counter
+
+    def find_many_and_delete(
+        self,
+        filter_fn: Callable,
+        max_workers: int | None = None,
+        timeout: float | None = None,
+    ) -> int:
+        """Finds one or more documents matching the filter and deletes their.
+
+        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.
+            timeout: The number of seconds to wait for the result if the future isn't done.
+                     If None, then there is no limit on the wait time.
+        """
+        branch_numbers: range = range(1, self.__max_branch_number)
+        search_task_fn: Callable = self._task_delete
+        hash_reduce_left: int = self.__hash_reduce_left
+        db_root: str = self.__db_root
+        class_model: T = self.__class_model
+        counter: int = 0
+        with concurrent.futures.ThreadPoolExecutor(max_workers) as executor:
+            for branch_number in branch_numbers:
+                future = executor.submit(
+                    search_task_fn,
+                    branch_number,
+                    filter_fn,
+                    hash_reduce_left,
+                    db_root,
+                    class_model,
+                )
+                counter += future.result(timeout)
+        if counter < 0:
+            self._sync_counter_documents(counter)
+        return abs(counter)

scruby/errors.py

@@ -1,14 +1,17 @@
-"""XLOT Exceptions."""
+"""Scruby Exceptions."""
 
 from __future__ import annotations
 
-__all__ = ("MetadataValueError",)
+__all__ = (
+    "ScrubyException",
+    "MetadataValueError",
+)
 
 
 class ScrubyException(Exception):
     """Root Custom Exception."""
 
-    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
+    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]  # noqa: D107
         super().__init__(*args, **kwargs)
 
 

{scruby-0.10.3.dist-info → scruby-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scruby
-Version: 0.10.3
+Version: 0.11.0
 Summary: A fast key-value storage library.
 Project-URL: Homepage, https://github.com/kebasyaty/scruby
 Project-URL: Repository, https://github.com/kebasyaty/scruby
@@ -175,7 +175,7 @@ from scruby import Scruby, constants
 from pprint import pprint as pp
 
 constants.DB_ROOT = "ScrubyDB"  # By default = "ScrubyDB"
-constants.LENGTH_REDUCTION_HASH = 6  # 256 branches in collection
+constants.HASH_REDUCE_LEFT = 6  # 256 branches in collection
                                      # (main purpose is tests).
 
 class User(BaseModel):
@@ -246,7 +246,7 @@ from scruby import Scruby, constants
 from pprint import pprint as pp
 
 constants.DB_ROOT = "ScrubyDB"  # By default = "ScrubyDB"
-constants.LENGTH_REDUCTION_HASH = 6  # 256 branches in collection
+constants.HASH_REDUCE_LEFT = 6  # 256 branches in collection
                                      # (main purpose is tests).
 
 class User(BaseModel):
@@ -274,7 +274,7 @@ async def main() -> None:
         await db.set_key(f"+44798612345{num}", user)
 
     # Find users by email.
-    users: list[User] | None = user_coll.find(
+    users: list[User] | None = user_coll.find_many(
         filter_fn=lambda doc: doc.email == "John_Smith_5@gmail.com" or doc.email == "John_Smith_8@gmail.com",
     )
     if users is not None:

scruby-0.11.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+scruby/__init__.py,sha256=wFwUS1KcLxfIopXOVS8gPue9fNzIIU2cVj_RgK5drz4,849
+scruby/constants.py,sha256=3LZfcxcuRqwzoB0-iogLMjKBZRdxfWJmTbyPwVRhQgY,1007
+scruby/db.py,sha256=Q7J4OKS2emiF0KzZClSjpBBLjohnccZ81T4pgoWNxqA,20269
+scruby/errors.py,sha256=aHQri4LNcFVQrSHwjyzb1fL8O49SwjYEU4QgMOo4uyA,622
+scruby/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scruby-0.11.0.dist-info/METADATA,sha256=yS9LDAYAqmxxn8cXHKbO7BmPEsX4o7th3VVFtgr9aoo,10824
+scruby-0.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scruby-0.11.0.dist-info/licenses/LICENSE,sha256=2zZINd6m_jNYlowdQImlEizyhSui5cBAJZRhWQURcEc,1095
+scruby-0.11.0.dist-info/RECORD,,

scruby-0.10.3.dist-info/RECORD

@@ -1,9 +0,0 @@
-scruby/__init__.py,sha256=wFwUS1KcLxfIopXOVS8gPue9fNzIIU2cVj_RgK5drz4,849
-scruby/constants.py,sha256=GbB-O0qaVdi5EHUp-zRAppFXLR-oHxpXUFVAOCpS0C8,1022
-scruby/db.py,sha256=J14Xjyc6iyb-cwBKiH8rJuioEHoYfNkLTezzvQBsJng,16181
-scruby/errors.py,sha256=4G0zNVzulBE9mM2iJLdg0EXP_W8n-L6EjZrkCCErvAU,574
-scruby/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scruby-0.10.3.dist-info/METADATA,sha256=JGgVH8QKtA-iGifWhNdSczfuglIT2RRw5njRuNKvG3M,10829
-scruby-0.10.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-scruby-0.10.3.dist-info/licenses/LICENSE,sha256=2zZINd6m_jNYlowdQImlEizyhSui5cBAJZRhWQURcEc,1095
-scruby-0.10.3.dist-info/RECORD,,