scruby 2.2.3__py3-none-any.whl → 2.3.1__py3-none-any.whl

scruby/__init__.py

@@ -36,5 +36,6 @@ __all__ = (
 
 
 from scruby.config import ScrubyConfig
-from scruby.db import Scruby, ScrubyModel
+from scruby.db import Scruby
 from scruby.mixins.find import ReturnType
+from scruby.model import ScrubyModel

scruby/cache.py

@@ -12,11 +12,19 @@ from typing import Any, ClassVar, Literal, Never, assert_never, final
 import orjson
 
 from scruby.config import ScrubyConfig
+from scruby.meta import Metadata
 
 
 @final
 class DocCache:
-    """Cache documents to optimize work with the database."""
+    """Cache documents to optimize work with the database.
+
+    Args:
+        collection_name (str): Collection name.
+
+    Returns:
+        None.
+    """
 
     # Cache structure:
     # {"CollectionName": {"hash_symbol": {"hash_symbol": {"hash_symbol": {"key_name": doc}}}}
@@ -24,7 +32,14 @@ class DocCache:
 
     @classmethod
     def create_structure(cls, collection_name: str) -> None:
-        """Create a cache structure for the collection."""
+        """Create structure of empty cache for collection.
+
+        Args:
+            collection_name (str): Collection name.
+
+        Returns:
+            None.
+        """
         if ScrubyConfig.HASH_REDUCE_LEFT == 0:
             return
 
@@ -44,29 +59,24 @@ class DocCache:
     @classmethod
     def load_cache(cls, subclasses: list[Any]) -> None:
         """Load all documents from the database into the cache."""
-        if ScrubyConfig.HASH_REDUCE_LEFT == 0:
-            return
-
         db_root: Path = Path(ScrubyConfig.db_root)
         HASH_REDUCE_LEFT: Literal[7, 6, 5, 0] = ScrubyConfig.HASH_REDUCE_LEFT
         MAX_NUMBER_BRANCH: Literal[16, 256, 4096, 4294967296] = ScrubyConfig.MAX_NUMBER_BRANCH
         branch_numbers: range = range(MAX_NUMBER_BRANCH)
 
-        # Leave function if database does not exist
-        if not db_root.exists():
-            return
+        for subclass in subclasses:
+            collection_name: str = subclass.__name__
 
-        # Get a list of created directories for collections
-        db_directory = Path(db_root)
-        all_entries = Path.iterdir(db_directory)
-        directory_names: list[str] = [entry.name for entry in all_entries if entry.name != ".env.meta"]
+            # Create metadata for the collection if it is missing
+            Metadata.create(collection_name)
 
-        for subclass in subclasses:
-            collection_name = subclass.__name__
+            if HASH_REDUCE_LEFT == 0:
+                continue
 
-            if collection_name in directory_names:
-                cls.create_structure(collection_name)
+            # Create a cache structure for the collection
+            cls.create_structure(collection_name)
 
+            # Get data from database and add to cache for collection
             for branch_number in branch_numbers:
                 branch_number_as_hash: str = f"{branch_number:08x}"[HASH_REDUCE_LEFT:]
                 separated_hash = "/".join(list(branch_number_as_hash))
@@ -84,7 +94,7 @@ class DocCache:
                     data: dict[str, str] = orjson.loads(data_json) or {}
                     for key, val in data.items():
                         doc = subclass.model_validate_json(val)
-                        match ScrubyConfig.HASH_REDUCE_LEFT:
+                        match HASH_REDUCE_LEFT:
                             case 7:
                                 cls.cache[collection_name][branch_number_as_hash[0]][key] = doc
                             case 6:

scruby/config.py

@@ -27,7 +27,7 @@ import sys
 from typing import Any, ClassVar, Literal, Never, assert_never, final
 from uuid import uuid4
 
-from scruby.utils import add_to_env, get_from_env
+from scruby.utils import Utils
 
 
 @final
@@ -77,10 +77,10 @@ class ScrubyConfig:
         delimiter: str = "/" if cls.sys_platform != "win32" else ""
         dotenv_path: str = f"{cls.db_root}{delimiter}.env.meta"
 
-        db_id: str | None = get_from_env(
+        db_id: str | None = Utils.get_from_env(
             key=key,
             dotenv_path=dotenv_path,
-        ) or add_to_env(
+        ) or Utils.add_to_env(
             key=key,
             value=str(uuid4())[:8],
             dotenv_path=dotenv_path,
@@ -116,10 +116,10 @@ class ScrubyConfig:
         delimiter: str = "/" if cls.sys_platform != "win32" else ""
         dotenv_path: str = f"{cls.db_root}{delimiter}.env.meta"
 
-        hash_reduce_left: str | None = get_from_env(
+        hash_reduce_left: str | None = Utils.get_from_env(
             key=key,
             dotenv_path=dotenv_path,
-        ) or add_to_env(
+        ) or Utils.add_to_env(
             key=key,
             value=str(cls.HASH_REDUCE_LEFT),
             dotenv_path=dotenv_path,

scruby/db.py

@@ -6,41 +6,22 @@
 
 from __future__ import annotations
 
-__all__ = (
-    "Scruby",
-    "ScrubyModel",
-)
+__all__ = ("Scruby",)
 
 import contextlib
 import re
 import zlib
-from datetime import datetime
 from shutil import rmtree
 from typing import Any, Literal, final
 
 from anyio import Path
-from pydantic import BaseModel
 from xloft import NamedTuple
 
 from scruby import mixins
 from scruby.cache import DocCache
 from scruby.config import ScrubyConfig
-
-
-class _Meta(BaseModel):
-    """Metadata of Collection."""
-
-    collection_name: str
-    hash_reduce_left: int
-    max_number_branch: int
-    counter_documents: int
-
-
-class ScrubyModel(BaseModel):
-    """Additional fields for models."""
-
-    created_at: datetime | None = None
-    updated_at: datetime | None = None
+from scruby.meta import Meta
+from scruby.model import ScrubyModel
 
 
 @final
@@ -57,97 +38,40 @@ class Scruby(
 
     def __init__(  # noqa: D107
         self,
+        class_model: Any,
     ) -> None:
+        if __debug__:
+            if ScrubyModel not in class_model.__bases__:
+                msg = "Scruby => Argument `class_model` does not contain the base class `ScrubyModel`."
+                raise AssertionError(msg)
+            if "key" not in list(class_model.model_fields.keys()):
+                msg = f"Model: {class_model.__name__} => The `key` field is missing."
+                raise AssertionError(msg)
+
         super().__init__()
-        self._meta = _Meta
+        self._class_model = class_model
         self._db_id = ScrubyConfig.db_id
         self._db_root = ScrubyConfig.db_root
         self._hash_reduce_left = ScrubyConfig.HASH_REDUCE_LEFT
         self._max_number_branch = ScrubyConfig.MAX_NUMBER_BRANCH
         self._max_workers = ScrubyConfig.max_workers
-
-    @classmethod
-    async def collection(cls, class_model: Any) -> Any:
-        """Asynchronous method for creating a new collection and accessing an existing collection.
-
-        Args:
-            class_model (Any): Class of Model (ScrubyModel).
-
-        Returns:
-            Instance of Scruby for access a collection.
-        """
-        if __debug__:
-            # Check if the object belongs to the class `ScrubyModel`
-            if ScrubyModel not in class_model.__bases__:
-                msg = (
-                    "Method: `collection` => argument `class_model` " + "does not contain the base class `ScrubyModel`!"
-                )
-                raise AssertionError(msg)
-            # Checking the model for the presence of a key.
-            model_fields = list(class_model.model_fields.keys())
-            if "key" not in model_fields:
-                msg = f"Model: {class_model.__name__} => The `key` field is missing!"
-                raise AssertionError(msg)
-            if "created_at" not in model_fields:
-                msg = f"Model: {class_model.__name__} => The `created_at` field is missing!"
-                raise AssertionError(msg)
-            if "updated_at" not in model_fields:
-                msg = f"Model: {class_model.__name__} => The `updated_at` field is missing!"
-                raise AssertionError(msg)
-            # Check the length of the collection name for an acceptable size.
-            len_db_root_absolut_path = len(str(await Path(ScrubyConfig.db_root).resolve()).encode("utf-8"))
-            len_model_name = len(class_model.__name__)
-            len_full_path_leaf = len_db_root_absolut_path + len_model_name + 26
-            if len_full_path_leaf > 255:
-                excess = len_full_path_leaf - 255
-                msg = (
-                    f"Model: {class_model.__name__} => The collection name is too long, "
-                    + f"it exceeds the limit of {excess} characters!"
-                )
-                raise AssertionError(msg)
-        # Create instance of Scruby
-        instance = cls()
-        # Add model class to Scruby
-        instance.__dict__["_class_model"] = class_model
-        # Create a path for metadata.
-        meta_dir_path_tuple = (
+        self._meta = Meta
+        self._meta_path = Path(
             ScrubyConfig.db_root,
             class_model.__name__,
             "meta",
-        )
-        instance.__dict__["_meta_path"] = Path(
-            *meta_dir_path_tuple,
             "meta.json",
         )
-        # Create metadata for collection, if missing.
-        meta_dir_path = Path(*meta_dir_path_tuple)
-        if not await meta_dir_path.exists():
-            # Create metadata.
-            await meta_dir_path.mkdir(parents=True)
-            meta = _Meta(
-                collection_name=class_model.__name__,
-                hash_reduce_left=instance.__dict__["_hash_reduce_left"],
-                max_number_branch=instance.__dict__["_max_number_branch"],
-                counter_documents=0,
-            )
-            # Save metadata of collection.
-            meta_json = meta.model_dump_json()
-            meta_path = Path(*(meta_dir_path, "meta.json"))
-            await meta_path.write_text(meta_json, "utf-8")
-            # Create a cache structure for the collection.
-            if instance.__dict__["_hash_reduce_left"] != 0:
-                DocCache.create_structure(class_model.__name__)
         # Plugins connection.
         plugin_list: dict[str, Any] = {}
         if ScrubyConfig.plugins is not None:
             for plugin in ScrubyConfig.plugins:
                 name = plugin.__name__
                 name = name[0].lower() + name[1:]
-                plugin_list[name] = plugin(scruby_self=instance)
-        instance.__dict__["plugins"] = NamedTuple(**plugin_list)
-        return instance
+                plugin_list[name] = plugin(scruby_self=self)
+        self.plugins = NamedTuple(**plugin_list)
 
-    async def get_meta(self) -> _Meta:
+    async def get_meta(self) -> Meta:
         """Asynchronous method for getting metadata of collection.
 
         This method is for internal use.
@@ -156,10 +80,10 @@ class Scruby(
             Metadata object.
         """
         meta_json = await self._meta_path.read_text()
-        meta: _Meta = self._meta.model_validate_json(meta_json)
+        meta: Meta = self._meta.model_validate_json(meta_json)
         return meta
 
-    async def _set_meta(self, meta: _Meta) -> None:
+    async def _set_meta(self, meta: Meta) -> None:
         """Asynchronous method for updating metadata of collection.
 
         This method is for internal use.
@@ -186,7 +110,7 @@ class Scruby(
         """
         meta_path = self._meta_path
         meta_json = await meta_path.read_text("utf-8")
-        meta: _Meta = self._meta.model_validate_json(meta_json)
+        meta: Meta = self._meta.model_validate_json(meta_json)
         meta.counter_documents += step
         meta_json = meta.model_dump_json()
         await meta_path.write_text(meta_json, "utf-8")
@@ -268,11 +192,15 @@ class Scruby(
         Returns:
             None.
         """
-        if __debug__ and plugins is not None:
-            for plugin in plugins:
-                if plugin.SCRUBY_VERSION != 2:
-                    msg = f"Plugin {plugin.__name__} does not apply to version 2."
-                    raise AssertionError(msg)
+        subclasses: list[Any] = ScrubyModel.__subclasses__()
+        if __debug__:
+            if len(subclasses) == 0:
+                raise AssertionError("Create least one model of document for your project.")
+            if plugins is not None:
+                for plugin in plugins:
+                    if plugin.SCRUBY_VERSION != 2:
+                        msg = f"Plugin {plugin.__name__} does not apply to version 2."
+                        raise AssertionError(msg)
 
         ScrubyConfig.db_root = db_root
         ScrubyConfig.HASH_REDUCE_LEFT = hash_reduce_left
@@ -280,4 +208,4 @@ class Scruby(
         ScrubyConfig.plugins = plugins
         ScrubyConfig.init_params()
         ScrubyConfig.check_hash_reduce_left()
-        DocCache.load_cache(ScrubyModel.__subclasses__())
+        DocCache.load_cache(subclasses)

scruby/meta.py

@@ -0,0 +1,57 @@
+"""Meta.
+
+Metadata management.
+"""
+
+from __future__ import annotations
+
+__all__ = (
+    "Meta",
+    "Metadata",
+)
+
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from scruby.config import ScrubyConfig
+
+
+class Meta(BaseModel):
+    """Structure of metadata for collection."""
+
+    collection_name: str
+    hash_reduce_left: int
+    max_number_branch: int
+    counter_documents: int
+
+
+class Metadata:
+    """Metadata management."""
+
+    @staticmethod
+    def create(collection_name: str) -> None:
+        """Create metadata for collection.
+
+        Args:
+            collection_name (str): Collection name.
+
+        Returns:
+            None.
+        """
+        meta_dir_path = Path(
+            ScrubyConfig.db_root,
+            collection_name,
+            "meta",
+        )
+        if not meta_dir_path.exists():
+            meta_dir_path.mkdir(parents=True)
+            meta = Meta(
+                collection_name=collection_name,
+                hash_reduce_left=ScrubyConfig.HASH_REDUCE_LEFT,
+                max_number_branch=ScrubyConfig.MAX_NUMBER_BRANCH,
+                counter_documents=0,
+            )
+            meta_json = meta.model_dump_json()
+            meta_path = Path(meta_dir_path, "meta.json")
+            meta_path.write_text(meta_json, "utf-8")

scruby/mixins/collection.py

@@ -11,10 +11,10 @@ __all__ = ("Collection",)
 from shutil import rmtree
 from typing import final
 
-from anyio import Path, to_thread
-
 from scruby.cache import DocCache
 from scruby.config import ScrubyConfig
+from scruby.meta import Metadata
+from scruby.model import ScrubyModel
 
 
 class Collection:
@@ -31,18 +31,15 @@ class Collection:
 
     @final
     @staticmethod
-    async def collection_list() -> list[str] | None:
-        """Asynchronous method for getting collection list."""
-        db_directory = Path(ScrubyConfig.db_root)
-        # Get all entries in the directory
-        all_entries = Path.iterdir(db_directory)
-        directory_names: list[str] = [entry.name async for entry in all_entries if entry.name != ".env.meta"]
-        return directory_names or None
+    def collection_list() -> list[str] | None:
+        """Synchronous method for getting collection list."""
+        collections = [item.__name__ for item in ScrubyModel.__subclasses__()]
+        return collections or None
 
     @final
     @staticmethod
-    async def delete_collection(collection_name: str) -> None:
-        """Asynchronous method for deleting a collection by its name.
+    def clear_collection(collection_name: str) -> None:
+        """Synchronous method to remove all documents from a collection.
 
         Args:
             collection_name (str): Collection name.
@@ -50,8 +47,14 @@ class Collection:
         Returns:
             None.
         """
+        # Clear collection on file system
         target_directory = f"{ScrubyConfig.db_root}/{collection_name}"
-        await to_thread.run_sync(rmtree, target_directory)  # pyrefly: ignore [bad-argument-type, incompatible-overload-residual]
+        rmtree(target_directory)
+        # Create metadata for collection
+        Metadata.create(collection_name)
+
+        # Clear collection in cache
         if ScrubyConfig.HASH_REDUCE_LEFT != 0:
             del DocCache.cache[collection_name]
+            DocCache.create_structure(collection_name)
         return

scruby/model.py

@@ -0,0 +1,17 @@
+"""Model."""
+
+from __future__ import annotations
+
+__all__ = ("ScrubyModel",)
+
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class ScrubyModel(BaseModel):
+    """Additional fields for models."""
+
+    created_at: datetime | None = None
+    updated_at: datetime | None = None

scruby/utils.py

@@ -2,10 +2,7 @@
 
 from __future__ import annotations
 
-__all__ = (
-    "get_from_env",
-    "add_to_env",
-)
+__all__ = ("Utils",)
 
 
 from pathlib import Path
@@ -13,59 +10,68 @@ from pathlib import Path
 from dotenv import dotenv_values
 
 
-def get_from_env(
-    key: str,
-    dotenv_path: Path | str = ".env",
-) -> str | None:
-    """Get value by key from .env file.
-
-    Returns:
-        None
-    """
-    assert len(key) > 0, "`get_from_env` => `key` must not be the empty string."
-
-    value: str | None = None
-
-    if isinstance(dotenv_path, str):
-        dotenv_path = Path(dotenv_path)
-
-    if dotenv_path.exists():
-        env_dict: dict[str, str | None] = dotenv_values(dotenv_path)
-        value = env_dict.get(key)
-
-    return value
-
-
-def add_to_env(
-    key: str,
-    value: str,
-    dotenv_path: Path | str = ".env",
-) -> str | None:
-    """Add key-value to .env file.
-
-    Returns:
-        `value` or None
-    """
-    assert len(key) > 0, "`add_to_env` => `key` must not be the empty string."
-    assert len(value) > 0, "`add_to_env` => `value` must not be the empty string."
-
-    if isinstance(dotenv_path, str):
-        assert len(dotenv_path) > 0, "`add_to_env` => `dotenv_path` must not be the empty string."
-        dotenv_path = Path(dotenv_path)
-
-    if dotenv_path.exists():
-        env_dict: dict[str, str | None] = dotenv_values(dotenv_path)
-        saved_value = env_dict.get(key)
-        if saved_value is None:
-            with dotenv_path.open("a+", encoding="utf-8") as env_file:
-                content = f"\n{key}={value}"
-                env_file.write(content)
+class Utils:
+    """Set of helper methods."""
+
+    @staticmethod
+    def get_from_env(
+        key: str,
+        dotenv_path: Path | str = ".env",
+    ) -> str | None:
+        """Get value by key from .env file."""
+        assert len(key) > 0, "`get_from_env` => `key` must not be the empty string."
+
+        value: str | None = None
+
+        if isinstance(dotenv_path, str):
+            dotenv_path = Path(dotenv_path)
+
+        if dotenv_path.exists():
+            env_dict: dict[str, str | None] = dotenv_values(dotenv_path)
+            value = env_dict.get(key)
+
+        return value
+
+    @staticmethod
+    def add_to_env(
+        key: str,
+        value: str,
+        dotenv_path: Path | str = ".env",
+    ) -> str | None:
+        """Add key-value to .env file."""
+        assert len(key) > 0, "`add_to_env` => `key` must not be the empty string."
+        assert len(value) > 0, "`add_to_env` => `value` must not be the empty string."
+
+        if isinstance(dotenv_path, str):
+            assert len(dotenv_path) > 0, "`add_to_env` => `dotenv_path` must not be the empty string."
+            dotenv_path = Path(dotenv_path)
+
+        if dotenv_path.exists():
+            env_dict: dict[str, str | None] = dotenv_values(dotenv_path)
+            saved_value = env_dict.get(key)
+            if saved_value is None:
+                with dotenv_path.open("a+", encoding="utf-8") as env_file:
+                    content = f"\n{key}={value}"
+                    env_file.write(content)
+            else:
+                raise KeyError(f"`add_to_env` => Key `{key}` already exists.")
         else:
-            raise KeyError(f"`add_to_env` => Key `{key}` already exists.")
-    else:
-        target_dir: str = "/".join(str(dotenv_path).split("/")[:-1])
-        Path(target_dir).mkdir(parents=True, exist_ok=True)
-        content = f"{key}={value}"
-        dotenv_path.write_text(data=content, encoding="utf-8")
-
-    return value
+            target_dir: str = "/".join(str(dotenv_path).split("/")[:-1])
+            Path(target_dir).mkdir(parents=True, exist_ok=True)
+            content = f"{key}={value}"
+            dotenv_path.write_text(data=content, encoding="utf-8")
+
+        return value
+
+    @staticmethod
+    def db_collection_list(db_root: Path | str) -> list[str] | None:
+        """Get a list of collections from a database directory."""
+        if isinstance(db_root, str):
+            assert len(db_root) > 0, "`add_to_env` => `dotenv_path` must not be the empty string."
+            db_root = Path(db_root)
+
+        directory_names: list[str] | None = None
+        if db_root.exists():
+            all_entries = Path.iterdir(db_root)
+            directory_names = [entry.name for entry in all_entries if entry.name != ".env.meta"] or None
+        return directory_names

{scruby-2.2.3.dist-info → scruby-2.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scruby
-Version: 2.2.3
+Version: 2.3.1
 Summary: Asynchronous library for building and managing a hybrid database, by scheme of key-value.
 Project-URL: Bug Tracker, https://github.com/kebasyaty/scruby/issues
 Project-URL: Changelog, https://github.com/kebasyaty/scruby/blob/v2/CHANGELOG.md
@@ -165,7 +165,7 @@ async def main() -> None:
     Scruby.run()
 
     # Get/Create a User collection
-    user_coll = await Scruby.collection(User)
+    user_coll = Scruby(User)
 
     # Create user
     user = User(
@@ -196,7 +196,7 @@ async def main() -> None:
     user_coll.collection_name()  # => User
 
     # Get collection list
-    coll_list = await Scruby.collection_list()  # => ["User"]
+    coll_list = Scruby.collection_list()  # => ["User"]
 
     # Get the number of documents in the collection from metadata
     await user_coll.estimated_document_count()  # => 1
@@ -204,8 +204,8 @@ async def main() -> None:
     # Get the number of documents comparable to the filter
     user_coll.count_documents(filter_fn=lambda doc: doc.first_name == "John") == 1
 
-    # Delete collection
-    await Scruby.delete_collection("User")
+    # Clear collection
+    Scruby.clear_collection("User")
 
     # Full database deletion
     # Hint: The main purpose is tests
@@ -248,7 +248,7 @@ async def main() -> None:
     Scruby.run()
 
     # Get/Create a Phone collection
-    phone_coll = await Scruby.collection(Phone)
+    phone_coll = Scruby(Phone)
 
     # Create phone
     phone = Phone(
@@ -325,7 +325,7 @@ async def main() -> None:
     Scruby.run()
 
     # Get/Create a Car collection
-    car_coll = await Scruby.collection(Car)
+    car_coll = Scruby(Car)
 
     # Create cars
     for num in range(1, 10):

scruby-2.3.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+scruby/__init__.py,sha256=YIR8zFx0GmS8ha96-MU9yCgKeYNIh1K8idlQckfg21E,1324
+scruby/aggregation.py,sha256=NBFxQqyRqUG2KIuD9fbl4uzSHJWTaskjiZ1YNBa-Zbo,3575
+scruby/cache.py,sha256=j_uRBF72p7kzUK6GMHIIqb8nM2RneCod45dbbI1KTjQ,4018
+scruby/config.py,sha256=oyBEOzmKy9vka23ZDvP8Jqu-HMYn8HCmJ0j2TfOs-0w,5127
+scruby/db.py,sha256=oulRx20bezbv2IwcsDq6TgsXo_zQz8ZE6ohmWg4kv2k,7107
+scruby/errors.py,sha256=lTWiHzyO5Es9Nkf7quODJjONGn6ifcL95qlpA4epQQM,1386
+scruby/meta.py,sha256=dfr8q3TWhVcEl-lZuH5yd9rbO9vAPBhXBO3VYCNcOWo,1283
+scruby/model.py,sha256=1infUd1G-zxj5Z93mNOp1Wi2anD6TKDgu5Y0KEVcH2k,292
+scruby/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scruby/utils.py,sha256=fCBBrp-tgRKh4bukjWRUQhkOsNCxGN4lbXcymBqCsbE,2587
+scruby/mixins/__init__.py,sha256=nT79e80zXliuTGhR9CFosI2-3PQUCKwXbR7wPiFwgrU,669
+scruby/mixins/collection.py,sha256=3Gn9zIT-WnSCBd-IgpE9tobRlW675YX__qaWoUOWIJM,1758
+scruby/mixins/count.py,sha256=CGpyOpsG25uC5utI2ByNxq2iTbJocj6w5tXrC1_cP40,2561
+scruby/mixins/custom_task.py,sha256=DIry4gBlTdaqZqymar-RrHSdhEiC2tn2pl9jmbk56zw,1547
+scruby/mixins/delete.py,sha256=InKVIud_ZYx9-CchUz_IygQDXMynNi4jQ0HKYeHC_R8,4328
+scruby/mixins/find.py,sha256=oEZRE6RqIBdwvNr8iSYyod8hI6ibi_egJP0pyXmJiss,9169
+scruby/mixins/keys.py,sha256=MvBy_8fQGROaQATK2qse2V8wR-xodPQG0KKZ2PK_t9U,10790
+scruby/mixins/update.py,sha256=TyxvxB-gNijlfzTmhwrq0ydvu0C3R-RihW5h5tJ96bM,4964
+scruby-2.3.1.dist-info/METADATA,sha256=8QxVl8_iyWBt6qwy-tx9yZRaKKtSb08qDaVy496jeLw,13382
+scruby-2.3.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+scruby-2.3.1.dist-info/licenses/GPL-3.0-LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+scruby-2.3.1.dist-info/licenses/MIT-LICENSE,sha256=mS0Wz0yGNB63gEcWEnuIb_lldDYV0sjRaO-o_GL6CWE,1074
+scruby-2.3.1.dist-info/RECORD,,

scruby-2.2.3.dist-info/RECORD

@@ -1,21 +0,0 @@
-scruby/__init__.py,sha256=DEtbZThadMKpKcGGjWyAFGu4IADg9ZYTb8WjfO_3Dqg,1300
-scruby/aggregation.py,sha256=NBFxQqyRqUG2KIuD9fbl4uzSHJWTaskjiZ1YNBa-Zbo,3575
-scruby/cache.py,sha256=krqvIhtbvhCFDjqOg1eg2uZFa4eGDRYI9ELTe6eJbpc,3961
-scruby/config.py,sha256=INAFqNAeF8BifIywjElC97rawfTLuqpRfieUdAO7A6k,5122
-scruby/db.py,sha256=OtAwHtXoHaF_obqMwxn157EtVppO0tO6Dx2lWGFBEiA,9999
-scruby/errors.py,sha256=lTWiHzyO5Es9Nkf7quODJjONGn6ifcL95qlpA4epQQM,1386
-scruby/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scruby/utils.py,sha256=ZwWxSyh_BAOQkXlIqXFOlX2lHVk9rfYGQiVqtTk8PpE,1865
-scruby/mixins/__init__.py,sha256=nT79e80zXliuTGhR9CFosI2-3PQUCKwXbR7wPiFwgrU,669
-scruby/mixins/collection.py,sha256=nTw0jnybox3iso0jzNoJiu61Hb-92zl84hdWhlWbik4,1792
-scruby/mixins/count.py,sha256=CGpyOpsG25uC5utI2ByNxq2iTbJocj6w5tXrC1_cP40,2561
-scruby/mixins/custom_task.py,sha256=DIry4gBlTdaqZqymar-RrHSdhEiC2tn2pl9jmbk56zw,1547
-scruby/mixins/delete.py,sha256=InKVIud_ZYx9-CchUz_IygQDXMynNi4jQ0HKYeHC_R8,4328
-scruby/mixins/find.py,sha256=oEZRE6RqIBdwvNr8iSYyod8hI6ibi_egJP0pyXmJiss,9169
-scruby/mixins/keys.py,sha256=MvBy_8fQGROaQATK2qse2V8wR-xodPQG0KKZ2PK_t9U,10790
-scruby/mixins/update.py,sha256=TyxvxB-gNijlfzTmhwrq0ydvu0C3R-RihW5h5tJ96bM,4964
-scruby-2.2.3.dist-info/METADATA,sha256=5HaLAyfWIbGGgRBZv79_f4Q0TKTe_RsIY_2uAswYEn8,13447
-scruby-2.2.3.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-scruby-2.2.3.dist-info/licenses/GPL-3.0-LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-scruby-2.2.3.dist-info/licenses/MIT-LICENSE,sha256=mS0Wz0yGNB63gEcWEnuIb_lldDYV0sjRaO-o_GL6CWE,1074
-scruby-2.2.3.dist-info/RECORD,,