pysdato 0.0.1__tar.gz

pysdato-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Stas Davydov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pysdato-0.0.1/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.1
+Name: pysdato
+Version: 0.0.1
+Summary: Simple JSON file storage for Python dataclasses and pydantic models, thread and multiprocess safe
+Home-page: https://github.com/stasdavydov/pys
+Author: Stas Davydov
+Author-email: davidovsv@yandex.ru
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: filelock==3.15.4
+
+# Python Object Storage 
+
+Simple fast JSON file storage for Python dataclasses and Pydantic models, thread and multiprocess safe. 
+
+----
+
+## Installation
+```shell
+pip install pysdato
+```
+
+## Usage
+The library is intended to store Python dataclasses or Pydantic models as JSON-files referenced by ID 
+and supports object hierarchy. 
+
+Let's say we have `Author` model. Object's ID is key point for persistence -- it will be used as name of
+file to store and load. We can have ID as object's field, but we may also keep it outside. 
+The default expected name of ID field is `id`, but it can be changed with `id_field` 
+parameter of `@saveable` decorator: `@saveable(id_field='email')`. 
+
+```python
+from dataclasses import dataclass
+import pys
+
+# Initialize storage with path where files will be saved
+storage = pys.storage('.storage')
+
+@pys.saveable
+@dataclass
+class Author:
+    name: str
+
+# Persist model Author
+leo = Author(name='Leo Tolstoy')
+leo_id = storage.save(leo)  # At this point the file `.storage/Author/<random uuid id>.json` will be saved
+                            # with content {"name":"Leo Tolstoy"}
+
+# Load model Author by its ID and check it's the same
+another_leo = storage.load(Author, leo_id)
+assert another_leo.name == leo.name
+```
+
+### Work with dependant data
+We may have a class that relates to other classes (like Authors and their Books). We can persist
+that dependant class separately (as we did before with `Author`), but we can also persist 
+in context of their "primary" class.
+
+```python
+import pys
+from pydantic import BaseModel
+
+# An author
+@pys.saveable
+class Author(BaseModel):
+    name: str
+
+# And a book
+@pys.saveable
+class Book(BaseModel):
+    title: str
+
+storage = pys.storage('.storage')
+
+# A few books of Leo Tolstoy
+leo = Author(name='Leo Tolstoy')
+war_and_peace = Book(title='War and peace')
+
+# Save Leo's book
+leo_id = storage.save(leo)
+wnp_id = storage.save(war_and_peace, leo)
+
+# One more author :)
+gpt = Author(name='Chat GPT')
+
+# Do we have the same book by GPT?
+gpt_war_and_peace = storage.load(Book, wnp_id, gpt)
+assert gpt_war_and_peace is None
+
+# Now it has :)
+storage.save(war_and_peace, gpt)
+gpt_war_and_peace = storage.load(Book, wnp_id, gpt)
+assert gpt_war_and_peace is not None
+```
+
+We may have as many dependant models as we need. Actually, it's the way to have model dependent indexes
+that let us easily faster get (dependent) model list by another model.
+```python
+from pydantic import BaseModel
+import pys
+
+# An author
+@pys.saveable
+class Author(BaseModel):
+    name: str
+
+# And a book
+@pys.saveable
+class Book(BaseModel):
+    title: str
+
+storage = pys.storage('.storage')
+
+# A few books of Leo Tolstoy
+leo = Author(name='Leo Tolstoy')
+war_and_peace = Book(title='War and peace')
+for_kids = Book(title='For Kids')
+
+storage.save(leo)
+storage.save(war_and_peace, leo)
+storage.save(for_kids, leo)
+
+leo_books = list(storage.list(Book, leo))
+assert len(leo_books) == 2
+assert war_and_peace in leo_books
+assert for_kids in leo_books
+```
+
+## Reference
+```python
+import pys
+
+# Initialize storage
+storage = pys.storage('.path-to-storage')
+
+# Save a model with optional relation to other models
+storage.save(model, [related_model | (RelatedModelClass, related_model_id), ...])
+
+# Load a model by ModelClass and model_id with optional relation to other models
+storage.load(ModelClass, model_id, [related_model | (RelatedModelClass, related_model_id), ...])
+
+# Delete a model by ModelClass and model_id with optional relation to other models
+storage.delete(ModelClass, model_id, [related_model | (RelatedModelClass, related_model_id), ...])
+
+# List models by specified ModelClass with optional relation to other models
+storage.list(ModelClass, [related_model | (RelatedModelClass, related_model_id), ...])
+```

pysdato-0.0.1/README.md

@@ -0,0 +1,136 @@
+# Python Object Storage 
+
+Simple fast JSON file storage for Python dataclasses and Pydantic models, thread and multiprocess safe. 
+
+----
+
+## Installation
+```shell
+pip install pysdato
+```
+
+## Usage
+The library is intended to store Python dataclasses or Pydantic models as JSON-files referenced by ID 
+and supports object hierarchy. 
+
+Let's say we have `Author` model. Object's ID is key point for persistence -- it will be used as name of
+file to store and load. We can have ID as object's field, but we may also keep it outside. 
+The default expected name of ID field is `id`, but it can be changed with `id_field` 
+parameter of `@saveable` decorator: `@saveable(id_field='email')`. 
+
+```python
+from dataclasses import dataclass
+import pys
+
+# Initialize storage with path where files will be saved
+storage = pys.storage('.storage')
+
+@pys.saveable
+@dataclass
+class Author:
+    name: str
+
+# Persist model Author
+leo = Author(name='Leo Tolstoy')
+leo_id = storage.save(leo)  # At this point the file `.storage/Author/<random uuid id>.json` will be saved
+                            # with content {"name":"Leo Tolstoy"}
+
+# Load model Author by its ID and check it's the same
+another_leo = storage.load(Author, leo_id)
+assert another_leo.name == leo.name
+```
+
+### Work with dependant data
+We may have a class that relates to other classes (like Authors and their Books). We can persist
+that dependant class separately (as we did before with `Author`), but we can also persist 
+in context of their "primary" class.
+
+```python
+import pys
+from pydantic import BaseModel
+
+# An author
+@pys.saveable
+class Author(BaseModel):
+    name: str
+
+# And a book
+@pys.saveable
+class Book(BaseModel):
+    title: str
+
+storage = pys.storage('.storage')
+
+# A few books of Leo Tolstoy
+leo = Author(name='Leo Tolstoy')
+war_and_peace = Book(title='War and peace')
+
+# Save Leo's book
+leo_id = storage.save(leo)
+wnp_id = storage.save(war_and_peace, leo)
+
+# One more author :)
+gpt = Author(name='Chat GPT')
+
+# Do we have the same book by GPT?
+gpt_war_and_peace = storage.load(Book, wnp_id, gpt)
+assert gpt_war_and_peace is None
+
+# Now it has :)
+storage.save(war_and_peace, gpt)
+gpt_war_and_peace = storage.load(Book, wnp_id, gpt)
+assert gpt_war_and_peace is not None
+```
+
+We may have as many dependant models as we need. Actually, it's the way to have model dependent indexes
+that let us easily faster get (dependent) model list by another model.
+```python
+from pydantic import BaseModel
+import pys
+
+# An author
+@pys.saveable
+class Author(BaseModel):
+    name: str
+
+# And a book
+@pys.saveable
+class Book(BaseModel):
+    title: str
+
+storage = pys.storage('.storage')
+
+# A few books of Leo Tolstoy
+leo = Author(name='Leo Tolstoy')
+war_and_peace = Book(title='War and peace')
+for_kids = Book(title='For Kids')
+
+storage.save(leo)
+storage.save(war_and_peace, leo)
+storage.save(for_kids, leo)
+
+leo_books = list(storage.list(Book, leo))
+assert len(leo_books) == 2
+assert war_and_peace in leo_books
+assert for_kids in leo_books
+```
+
+## Reference
+```python
+import pys
+
+# Initialize storage
+storage = pys.storage('.path-to-storage')
+
+# Save a model with optional relation to other models
+storage.save(model, [related_model | (RelatedModelClass, related_model_id), ...])
+
+# Load a model by ModelClass and model_id with optional relation to other models
+storage.load(ModelClass, model_id, [related_model | (RelatedModelClass, related_model_id), ...])
+
+# Delete a model by ModelClass and model_id with optional relation to other models
+storage.delete(ModelClass, model_id, [related_model | (RelatedModelClass, related_model_id), ...])
+
+# List models by specified ModelClass with optional relation to other models
+storage.list(ModelClass, [related_model | (RelatedModelClass, related_model_id), ...])
+```

pysdato-0.0.1/pys/__init__.py

@@ -0,0 +1,192 @@
+import abc
+import json
+import shutil
+import uuid
+from dataclasses import is_dataclass, asdict
+from pathlib import Path
+from typing import Type, Optional, Tuple, Iterable, Any
+from typing import TypeVar
+from filelock import FileLock
+
+
+def saveable(cls=None, /, field_as_id: str = 'id'):
+    def wrapper(cls):
+        def my_id_or_default(self):
+            __default_id__ = '__default_id__'
+            if hasattr(self, field_as_id):
+                if getattr(self, field_as_id, None) is None:
+                    setattr(self, field_as_id, str(uuid.uuid4()))
+                return getattr(self, field_as_id)
+            elif hasattr(self, '__loaded_id__'):
+                setattr(self, __default_id__, getattr(self, '__loaded_id__'))
+            elif getattr(self, __default_id__, None) is None:
+                setattr(self, __default_id__, str(uuid.uuid4()))
+            return getattr(self, __default_id__)
+
+        setattr(cls, '__my_id__', my_id_or_default)
+        if not hasattr(cls, '__json__'):
+            if is_dataclass(cls):
+                setattr(cls, '__json__',
+                        lambda self:
+                            json.dumps(
+                                asdict(self),
+                                separators=(',', ':')
+                            )
+                        )
+            elif is_pydantic(cls):
+                setattr(cls, '__json__', lambda self: self.model_dump_json())
+            else:
+                raise NotImplementedError(
+                    f'The class {cls} is not @dataclass nor Pydantic Model and does not have __json__() method.'
+                    f'Please implement __json__() method by yourself.')
+        return cls
+
+    if cls is None:
+        return wrapper
+    else:
+        return wrapper(cls)
+
+
+def is_pydantic(cls):
+    return any(filter(lambda c: c.__name__ == 'BaseModel', cls.__mro__))
+
+
+StoredModel = TypeVar('StoredModel')
+RelatedModel = TypeVar('RelatedModel')
+
+
+class BaseStorage(abc.ABC):
+    """
+    Abstract base storage
+    """
+    def load(self, model_class: Type[StoredModel], model_id: str,
+             *related_model: RelatedModel | Tuple[RelatedModel, str]) \
+            -> Optional[StoredModel]:
+        """
+        Load model.
+
+        :param model_class: Class of the model.
+        :param model_id: Model ID.
+        :param related_model: Related model(s) -- model that the loaded model is belong to.
+        :return: Loaded model or None in case if model is not found.
+        """
+        raise NotImplementedError
+
+    def save(self, model: StoredModel,
+             *related_model: RelatedModel | Tuple[RelatedModel, str]) -> Any:
+        """
+        Save model.
+
+        :param model: A model.
+        :param related_model: Related model(s) -- model that the stored model is belong to.
+        :return Returns saved model id
+        """
+        raise NotImplementedError
+
+    def delete(self, model_class: Type[StoredModel], model_id: str,
+               *related_model: RelatedModel | Tuple[RelatedModel, str]) -> None:
+        """
+        Delete model.
+
+        :param model_class: Model class.
+        :param model_id: Model ID.
+        :param related_model: Related model(s) -- model that the deleted model is belong to.
+        """
+        raise NotImplementedError
+
+    def list(self, model_class: Type[StoredModel],
+             *related_model: RelatedModel | Tuple[RelatedModel, str]) -> Iterable[StoredModel]:
+        """
+        List models.
+        :param model_class: Model class
+        :param related_model: Related model(s) -- model that the listed models are belong to.
+        :return: List of found models.
+        """
+        raise NotImplementedError
+
+
+class FileStorage(BaseStorage):
+    """
+    File based storage implementation. Thread and interprocess safe.
+    """
+    base_path: Path
+
+    def __init__(self, base_path: str | Path) -> None:
+        """
+        Base path for the storage files
+        :param base_path: base path.
+        """
+        self.base_path = base_path if isinstance(base_path, Path) else Path(base_path)
+
+    @staticmethod
+    def _get_model_path(model_class: Type[StoredModel], model_id: str,
+                        *related_model: RelatedModel | Tuple[Type[RelatedModel], str]) -> Path:
+        path = Path()
+        if not related_model:
+            path /= ''
+        else:
+            for model in related_model:
+                if isinstance(model, tuple):
+                    path /= FileStorage._get_model_path(*model)
+                else:
+                    path /= FileStorage._get_model_path(model.__class__, model.__my_id__())
+
+        return path / model_class.__name__ / model_id
+
+    def _prepare_file(self, model_class: Type[StoredModel], model_id: str,
+                      *related_model: RelatedModel | Tuple[RelatedModel, str]):
+        path = self.base_path / FileStorage._get_model_path(model_class, model_id, *related_model).with_suffix('.json')
+        lock = path.with_suffix('.lock')
+        path.parent.mkdir(parents=True, exist_ok=True)
+        return path, FileLock(lock)
+
+    def save(self, model: StoredModel,
+             *related_model: RelatedModel | Tuple[RelatedModel, str]) -> Any:
+        model_id = model.__my_id__()
+        path, lock = self._prepare_file(model.__class__, model_id, *related_model)
+        with lock:
+            with path.open('w', encoding='UTF-8') as f:
+                f.write(model.__json__())
+                return model_id
+
+    def load(self, model_class: Type[StoredModel], model_id: str,
+             *related_model: RelatedModel | Tuple[RelatedModel, str]) -> Optional[StoredModel]:
+        path, lock = self._prepare_file(model_class, model_id, *related_model)
+        with lock:
+            if not path.exists():
+                return None
+            with open(path, 'r') as f:
+                content = json.load(f)
+            if is_pydantic(model_class):
+                model = model_class.model_validate(content)
+            else:
+                model = model_class(**content)
+            setattr(model, '__loaded_id__', model_id)
+            return model
+
+    def delete(self, model_class: Type[StoredModel], model_id: str,
+               *related_model: RelatedModel | Tuple[RelatedModel, str]) -> None:
+        path, lock = self._prepare_file(model_class, model_id, *related_model)
+        with lock:
+            path.unlink(missing_ok=True)
+            sub_path = path.with_suffix('')
+            if sub_path.exists():
+                shutil.rmtree(sub_path)
+
+    def list(self, model_class: Type[StoredModel],
+             *related_model: RelatedModel | Tuple[RelatedModel, str]) -> Iterable[StoredModel]:
+
+        path, lock = self._prepare_file(model_class, '__list__', *related_model)
+        with lock:
+            for p in path.parent.glob('*.json'):
+                yield self.load(model_class, p.with_suffix('').name, *related_model)
+
+    def __str__(self) -> str:
+        return f'file.Storage(base_path={self.base_path})'
+
+
+def storage(base_path: str | Path):
+    return FileStorage(base_path)
+
+
+__all__ = ('saveable', 'storage', )

pysdato-0.0.1/pys/pydantic.py

@@ -0,0 +1,26 @@
+import uuid
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class ModelWithID(BaseModel):
+    """
+    Base class for models with `id` field prefilled with random UUID if not initialized.
+    """
+    id: str = None
+
+    def __init__(self, **data: Any) -> None:
+        """
+        Initialize a model
+        :param data: model fields
+        """
+        super().__init__(**data)
+        if self.id is None:
+            self.id = str(uuid.uuid4())
+
+    def __my_id__(self):
+        return self.id
+
+    def __json__(self):
+        return self.model_dump_json()

pysdato-0.0.1/pysdato.egg-info/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.1
+Name: pysdato
+Version: 0.0.1
+Summary: Simple JSON file storage for Python dataclasses and pydantic models, thread and multiprocess safe
+Home-page: https://github.com/stasdavydov/pys
+Author: Stas Davydov
+Author-email: davidovsv@yandex.ru
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: filelock==3.15.4
+
+# Python Object Storage 
+
+Simple fast JSON file storage for Python dataclasses and Pydantic models, thread and multiprocess safe. 
+
+----
+
+## Installation
+```shell
+pip install pysdato
+```
+
+## Usage
+The library is intended to store Python dataclasses or Pydantic models as JSON-files referenced by ID 
+and supports object hierarchy. 
+
+Let's say we have `Author` model. Object's ID is key point for persistence -- it will be used as name of
+file to store and load. We can have ID as object's field, but we may also keep it outside. 
+The default expected name of ID field is `id`, but it can be changed with `id_field` 
+parameter of `@saveable` decorator: `@saveable(id_field='email')`. 
+
+```python
+from dataclasses import dataclass
+import pys
+
+# Initialize storage with path where files will be saved
+storage = pys.storage('.storage')
+
+@pys.saveable
+@dataclass
+class Author:
+    name: str
+
+# Persist model Author
+leo = Author(name='Leo Tolstoy')
+leo_id = storage.save(leo)  # At this point the file `.storage/Author/<random uuid id>.json` will be saved
+                            # with content {"name":"Leo Tolstoy"}
+
+# Load model Author by its ID and check it's the same
+another_leo = storage.load(Author, leo_id)
+assert another_leo.name == leo.name
+```
+
+### Work with dependant data
+We may have a class that relates to other classes (like Authors and their Books). We can persist
+that dependant class separately (as we did before with `Author`), but we can also persist 
+in context of their "primary" class.
+
+```python
+import pys
+from pydantic import BaseModel
+
+# An author
+@pys.saveable
+class Author(BaseModel):
+    name: str
+
+# And a book
+@pys.saveable
+class Book(BaseModel):
+    title: str
+
+storage = pys.storage('.storage')
+
+# A few books of Leo Tolstoy
+leo = Author(name='Leo Tolstoy')
+war_and_peace = Book(title='War and peace')
+
+# Save Leo's book
+leo_id = storage.save(leo)
+wnp_id = storage.save(war_and_peace, leo)
+
+# One more author :)
+gpt = Author(name='Chat GPT')
+
+# Do we have the same book by GPT?
+gpt_war_and_peace = storage.load(Book, wnp_id, gpt)
+assert gpt_war_and_peace is None
+
+# Now it has :)
+storage.save(war_and_peace, gpt)
+gpt_war_and_peace = storage.load(Book, wnp_id, gpt)
+assert gpt_war_and_peace is not None
+```
+
+We may have as many dependant models as we need. Actually, it's the way to have model dependent indexes
+that let us easily faster get (dependent) model list by another model.
+```python
+from pydantic import BaseModel
+import pys
+
+# An author
+@pys.saveable
+class Author(BaseModel):
+    name: str
+
+# And a book
+@pys.saveable
+class Book(BaseModel):
+    title: str
+
+storage = pys.storage('.storage')
+
+# A few books of Leo Tolstoy
+leo = Author(name='Leo Tolstoy')
+war_and_peace = Book(title='War and peace')
+for_kids = Book(title='For Kids')
+
+storage.save(leo)
+storage.save(war_and_peace, leo)
+storage.save(for_kids, leo)
+
+leo_books = list(storage.list(Book, leo))
+assert len(leo_books) == 2
+assert war_and_peace in leo_books
+assert for_kids in leo_books
+```
+
+## Reference
+```python
+import pys
+
+# Initialize storage
+storage = pys.storage('.path-to-storage')
+
+# Save a model with optional relation to other models
+storage.save(model, [related_model | (RelatedModelClass, related_model_id), ...])
+
+# Load a model by ModelClass and model_id with optional relation to other models
+storage.load(ModelClass, model_id, [related_model | (RelatedModelClass, related_model_id), ...])
+
+# Delete a model by ModelClass and model_id with optional relation to other models
+storage.delete(ModelClass, model_id, [related_model | (RelatedModelClass, related_model_id), ...])
+
+# List models by specified ModelClass with optional relation to other models
+storage.list(ModelClass, [related_model | (RelatedModelClass, related_model_id), ...])
+```

pysdato-0.0.1/pysdato.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.py
+pys/__init__.py
+pys/pydantic.py
+pysdato.egg-info/PKG-INFO
+pysdato.egg-info/SOURCES.txt
+pysdato.egg-info/dependency_links.txt
+pysdato.egg-info/requires.txt
+pysdato.egg-info/top_level.txt
+tests/test_file_storage.py
+tests/test_sample1.py
+tests/test_sample2.py
+tests/test_sample3.py
+tests/test_with_id.py

pysdato-0.0.1/pysdato.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pysdato-0.0.1/pysdato.egg-info/requires.txt

@@ -0,0 +1 @@
+filelock==3.15.4

pysdato-0.0.1/pysdato.egg-info/top_level.txt

@@ -0,0 +1 @@
+pys

pysdato-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pysdato-0.0.1/setup.py

@@ -0,0 +1,35 @@
+import pathlib
+from distutils.core import setup
+
+# The directory containing this file
+HERE = pathlib.Path(__file__).parent
+
+# The text of the README file
+README = (HERE / "README.md").read_text()
+
+setup(name='pysdato',
+      version='0.0.1',
+      description='Simple JSON file storage for Python dataclasses and pydantic models, thread and multiprocess safe',
+      long_description=README,
+      long_description_content_type="text/markdown",
+      url="https://github.com/stasdavydov/pys",
+      author="Stas Davydov",
+      author_email="davidovsv@yandex.ru",
+      license="MIT",
+      classifiers=[
+          "Development Status :: 5 - Production/Stable",
+          "License :: OSI Approved :: MIT License",
+          "Operating System :: OS Independent",
+          "Intended Audience :: Developers",
+          "Programming Language :: Python :: 3",
+          "Programming Language :: Python :: 3.10",
+          "Topic :: Database :: Database Engines/Servers",
+          "Topic :: Software Development :: Libraries",
+          "Topic :: Software Development :: Libraries :: Python Modules",
+      ],
+      packages=['pys'],
+      include_package_data=False,
+      install_requires=[
+          'filelock==3.15.4',
+      ],
+      )

pysdato-0.0.1/tests/test_file_storage.py

@@ -0,0 +1,93 @@
+import shutil
+from pathlib import Path
+
+
+from .model import BotOwner, Bot, BotResponse
+import pys
+
+base_path = Path(__file__).parent / '.storage'
+shutil.rmtree(base_path, ignore_errors=True)
+base_path.mkdir(parents=True, exist_ok=False)
+storage = pys.storage(base_path)
+
+
+def test_file_storage():
+    bot_owner = BotOwner(username='itisme', first_name='Test', last_name='Tester')
+    assert storage.base_path.absolute() == base_path.absolute()
+    path, _ = storage._prepare_file(BotOwner, bot_owner.id)
+    assert path.absolute() == (base_path / 'BotOwner' / bot_owner.id).with_suffix('.json').absolute()
+    storage.delete(bot_owner.__class__, bot_owner.id)
+
+
+def test_load():
+    owner = BotOwner(username='itisme', first_name='Test', last_name='Tester')
+    storage.save(owner)
+    bot_owner = storage.load(BotOwner, owner.id)
+    assert bot_owner is not None
+    assert bot_owner.id == owner.id
+    assert bot_owner.username == owner.username
+    assert bot_owner.first_name == owner.first_name
+    assert bot_owner.last_name == owner.last_name
+    storage.delete(bot_owner.__class__, bot_owner.id)
+
+
+def test_save():
+    bot_owner2a = BotOwner(first_name='Second', last_name='', username='')
+    storage.save(bot_owner2a)
+    assert (storage.base_path / 'BotOwner' / bot_owner2a.id).with_suffix('.json').exists()
+    bot_owner2b = storage.load(BotOwner, bot_owner2a.id)
+    assert bot_owner2b == bot_owner2a
+
+    storage.delete(BotOwner, bot_owner2a.id)
+    assert not (storage.base_path / 'BotOwner' / bot_owner2a.id).with_suffix('.json').exists()
+
+
+def test_related_model():
+    bot_owner2 = BotOwner(first_name='Second', last_name='Owner', username='')
+    bot_owner3 = BotOwner(first_name='Third', last_name='Owner', username='')
+    storage.save(Bot(id='3', name='A bot'), bot_owner2)
+    storage.save(Bot(id='3', name='B bot'), bot_owner3)
+
+    bot_a = storage.load(Bot, '3', bot_owner2)
+    assert bot_a.id == '3'
+    assert bot_a.name == 'A bot'
+
+    bot_b = storage.load(Bot, '3', bot_owner3)
+    assert bot_b.id == '3'
+    assert bot_b.name == 'B bot'
+
+    storage.delete(bot_owner2.__class__, bot_owner2.id)
+    storage.delete(bot_owner3.__class__, bot_owner3.id)
+
+
+def test_related_models():
+    bot_owner = BotOwner(first_name='Second', last_name='Owner', username='')
+    bot = Bot(id='1', name='A bot')
+    storage.save(bot, bot_owner)
+    response = BotResponse(author=bot_owner, content='123')
+    storage.save(response, bot_owner, bot)
+
+    bot_response = storage.load(BotResponse, response.id, bot_owner, bot)
+    assert bot_response.id == response.id
+    assert bot_response.content == response.content
+
+    bot_response = storage.load(BotResponse, response.id, bot_owner, (Bot, bot.id))
+    assert bot_response.id == response.id
+    assert bot_response.content == response.content
+
+    storage.delete(bot_owner.__class__, bot_owner.id)
+
+
+def test_list():
+    bot_owner = BotOwner(first_name='Second', last_name='Owner', username='')
+    storage.save(Bot(id='1', name='Bot #1'), bot_owner)
+    storage.save(Bot(id='2', name='Bot #2'), bot_owner)
+    storage.save(Bot(id='3', name='Bot #3'), bot_owner)
+
+    bot_list = list(storage.list(Bot, bot_owner))
+    assert len(bot_list) == 3
+    bot_ids = ('1', '2', '3')
+    for bot in bot_list:
+        assert bot.id in bot_ids
+
+    storage.delete(bot_owner.__class__, bot_owner.id)

pysdato-0.0.1/tests/test_sample1.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+
+import pys
+from pys.pydantic import ModelWithID
+
+
+def test_sample_pydantic():
+    # Initialize storage with path where files will be saved
+    storage = pys.storage('.storage')
+
+    class Author(ModelWithID):
+        name: str
+
+    # Persist model Author
+    leo = Author(name='Leo Tolstoy')
+    storage.save(leo)
+
+    # Load model Author by its ID and check it's the same
+    another_leo = storage.load(Author, leo.id)
+    assert another_leo.id == leo.id
+    assert another_leo.name == leo.name
+
+
+def test_sample_dataclass():
+    # Initialize storage with path where files will be saved
+    storage = pys.storage('.storage')
+
+    @pys.saveable
+    @dataclass
+    class Author:
+        name: str
+
+    # Persist model Author
+    leo = Author(name='Leo Tolstoy')
+    leo_id = storage.save(leo)
+
+    # Load model Author by its ID and check it's the same
+    another_leo = storage.load(Author, leo_id)
+    assert another_leo.name == leo.name

pysdato-0.0.1/tests/test_sample2.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel
+
+import pys
+
+
+def test_sample_pydantic2():
+    # An author
+    @pys.saveable
+    class Author(BaseModel):
+        name: str
+
+    # And a book
+    @pys.saveable
+    class Book(BaseModel):
+        title: str
+
+    storage = pys.storage('.storage')
+
+    # A few books of Leo Tolstoy
+    leo = Author(name='Leo Tolstoy')
+    war_and_peace = Book(title='War and peace')
+
+    # Save Leo's book
+    storage.save(leo)
+    wnp_id = storage.save(war_and_peace, leo)
+
+    # One more author :)
+    gpt = Author(name='Chat GPT')
+
+    # Do we have the same book by GPT?
+    gpt_war_and_peace = storage.load(Book, wnp_id, gpt)
+    assert gpt_war_and_peace is None
+
+    # Now it has :)
+    storage.save(war_and_peace, gpt)
+    gpt_war_and_peace = storage.load(Book, wnp_id, gpt)
+    assert gpt_war_and_peace is not None

pysdato-0.0.1/tests/test_sample3.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+
+import pys
+
+
+# An author
+@pys.saveable
+class Author(BaseModel):
+    name: str
+
+
+# And a book
+@pys.saveable
+class Book(BaseModel):
+    title: str
+
+
+def test_sample():
+    storage = pys.storage('.storage')
+
+    # A few books of Leo Tolstoy
+    leo = Author(name='Leo Tolstoy')
+    war_and_peace = Book(title='War and peace')
+    for_kids = Book(title='For Kids')
+
+    storage.save(leo)
+    storage.save(war_and_peace, leo)
+    storage.save(for_kids, leo)
+
+    leo_books = list(storage.list(Book, leo))
+    assert len(leo_books) == 2
+    assert war_and_peace in leo_books
+    assert for_kids in leo_books

pysdato-0.0.1/tests/test_with_id.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+
+import pys
+
+
+@pys.saveable(field_as_id='some_other')
+@dataclass
+class A:
+    some_other: str
+
+
+@pys.saveable
+@dataclass
+class B:
+    id: str
+
+
+@pys.saveable
+@dataclass
+class C:
+    name: str
+
+
+def test_with_id():
+    a = A(some_other='xyz')
+    assert a.__my_id__() is not None
+    assert a.some_other is not None
+    assert a.some_other == a.__my_id__()
+    assert a.__json__() is not None
+    assert a.__json__() == '{"some_other":"' f'{a.__my_id__()}' '"}'
+
+    b = B(id='123')
+    assert b.__my_id__() is not None
+    assert b.id == b.__my_id__()
+    assert b.id == '123'
+    assert b.__json__() is not None
+    assert b.__json__() == '{"id":"' f'{b.id}' '"}'
+
+    c = C(name='C class')
+    assert c.__my_id__() is not None
+    assert c.__json__() is not None
+    assert c.__json__() == f'{{"name":"{c.name}"}}'