Initial commit

Author: jefersondaniel

.coveragerc

@@ -0,0 +1,4 @@
+[run]
+branch = False
+omit=
+    pydantic_mongo/__init__.py

.flake8

@@ -0,0 +1,2 @@
+[flake8]
+max-line-length=140

.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: Tests
+on: push
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.6, 3.7, 3.8, 3.9]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements_test.txt
+    - name: Test with phulp
+      run: |
+        phulp test

.gitignore

@@ -0,0 +1,14 @@
+*.pyc
+*.pyo
+.cache
+.coverage
+.coverage.*
+.eggs
+.vscode
+coverage.xml
+venv/
+dist/
+build/
+pydantic_mongo.egg-info/
+var/
+.pytest_cache/

LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Jeferson <[email protected]> (https://jefersondaniel.com)
+
+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.

Makefile

@@ -0,0 +1,3 @@
+release:
+	python setup.py sdist upload
+	python setup.py bdist_wheel upload

README.rst

@@ -0,0 +1,81 @@
+Pydantic Mongo
+======================================
+
+|Build Status| |Version| |Pyversions|
+
+Document object mapper for pydantic and pymongo
+
+Documentation
+~~~~~~~~~~~~~
+
+Usage
+^^^^^
+
+Install:
+''''''''
+
+.. code:: bash
+
+   $ pip install pydantic-mongo
+
+''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+.. code:: python
+
+    from pydantic import BaseModel
+    from pydantic_mongo import AbstractRepository, ObjectIdField
+    from pymongo import MongoClient
+
+    class Foo(BaseModel):
+        count: int
+        size: float = None
+
+    class Bar(BaseModel):
+        apple = 'x'
+        banana = 'y'
+
+    class Spam(BaseModel):
+        id: ObjectIdField = None
+        foo: Foo
+        bars: List[Bar]
+
+        class Config:
+            # The ObjectIdField creates an bson ObjectId value, so its necessary to setup the json encoding
+            json_encoders = {ObjectId: str}
+
+    class SpamRepository(AbstractRepository[Spam]):
+        class Meta:
+            collection_name = 'spams'
+
+    client = MongoClient(os.environ["MONGODB_URL"])
+    database = client[os.environ["MONGODB_DATABASE"]]
+
+    spam = Spam(foo=Foo(count=1, size=1.0),bars=[Bar()])
+
+    spam_repository = SpamRepository(database=database)
+
+    # Insert / Update
+    spam_repository.save(spam)
+
+    # Delete
+    spam_repository.delete(spam)
+
+    # Find One By Id
+    result = spam_repository.find_one_by_id(spam.id)
+
+    # Find One By Query
+    result = spam_repository.find_one_by({'foo.count': 1})
+
+    # Find By Query
+    results = spam_repository.find_by({'foo.count': {'$gte': 1}})
+
+''''
+
+.. |Build Status| image:: https://travis-ci.org/jefersondaniel/pydantic-mongo.svg
+   :target: https://travis-ci.org/jefersondaniel/pydantic-mongo
+
+.. |Version| image:: https://badge.fury.io/py/pydantic-mongo.svg
+   :target: https://pypi.python.org/pypi/pydantic-mongo
+
+.. |Pyversions| image:: https://img.shields.io/pypi/pyversions/pydantic-mongo.svg
+   :target: https://pypi.python.org/pypi/pydantic-mongo

phulpyfile.py

@@ -0,0 +1,38 @@
+import xml.etree.ElementTree as ET
+from os import system, unlink
+from os.path import dirname, join
+from phulpy import task
+
+
+@task
+def test(phulpy):
+    phulpy.start(['lint', 'typecheck', 'unit_test'])
+
+
+@task
+def lint(phulpy):
+    result = system('flake8 pydantic_mongo')
+    if result:
+        raise Exception('lint test failed')
+
+
+@task
+def unit_test(phulpy):
+    result = system(
+        'pytest --cov-report term-missing'
+        + ' --cov-report xml --cov=pydantic_mongo test'
+    )
+    if result:
+        raise Exception('Unit tests failed')
+    coverage_path = join(dirname(__file__), 'coverage.xml')
+    xml = ET.parse(coverage_path).getroot()
+    unlink(coverage_path)
+    if float(xml.get('line-rate')) < 1:
+        raise Exception('Unit test is not fully covered')
+
+
+@task
+def typecheck(phulpy):
+    result = system(r'find ./pydantic_mongo -name "*.py" -exec mypy --ignore-missing-imports --follow-imports=skip --strict-optional {} \+')
+    if result:
+        raise Exception('lint test failed')

pydantic_mongo/__init__.py

@@ -0,0 +1,2 @@
+from .abstract_repository import AbstractRepository # noqa
+from .fields import ObjectIdField # noqa

pydantic_mongo/abstract_repository.py

@@ -0,0 +1,81 @@
+from typing import Optional, TypeVar, Generic
+from pydantic import BaseModel
+
+T = TypeVar('T', bound=BaseModel)
+
+
+class AbstractRepository(Generic[T]):
+    def __init__(self, database):
+        super().__init__()
+        self.__database = database
+        self.__document_class = self.__orig_bases__[0].__args__[0]
+        self.__collection_name = self.Meta.collection_name
+        self.__validate()
+
+    def get_collection(self):
+        return self.__database[self.__collection_name]
+
+    def __validate(self):
+        if not issubclass(self.__document_class, BaseModel):
+            raise Exception('Document class should inherit BaseModel')
+        if 'id' not in self.__document_class.__fields__:
+            raise Exception('Document class should have id field')
+        if not self.__collection_name:
+            raise Exception('Meta should contain collection name')
+
+    def to_document(self, model: T) -> dict:
+        result = model.dict()
+        result.pop('id')
+        if model.id:
+            result['_id'] = model.id
+        return result
+
+    def __to_query(self, data: dict):
+        query = data.copy()
+        if 'id' in data:
+            query['_id'] = query.pop('id')
+        return query
+
+    def to_model(self, data: dict) -> T:
+        data_copy = data.copy()
+        if '_id' in data_copy:
+            data_copy['id'] = data_copy.pop('_id')
+        return self.__document_class.parse_obj(data_copy)
+
+    def save(self, model: T):
+        document = self.to_document(model)
+
+        if model.id:
+            mongo_id = document.pop('_id')
+            self.get_collection().update_one({'_id': mongo_id}, {'$set': document})
+            return
+
+        result = self.get_collection().insert_one(document)
+        model.id = result.inserted_id
+        return result
+
+    def delete(self, model: T):
+        return self.get_collection().delete_one({'_id': model.id})
+
+    def find_one_by_id(self, id: str) -> Optional[T]:
+        return self.find_one_by({'id': id})
+
+    def find_one_by(self, query: dict) -> Optional[T]:
+        result = self.get_collection().find_one(self.__to_query(query))
+        return self.to_model(result) if result else None
+
+    def find_by(
+        self,
+        query: dict,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        sort=None
+    ):
+        cursor = self.get_collection().find(self.__to_query(query))
+        if limit:
+            cursor.limit(limit)
+        if skip:
+            cursor.skip(skip)
+        if sort:
+            cursor.sort(sort)
+        return map(self.to_model, cursor)

pydantic_mongo/fields.py

@@ -0,0 +1,18 @@
+from bson import ObjectId
+
+
+class ObjectIdField():
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, value):
+        if not ObjectId.is_valid(value):
+            raise ValueError("Invalid id")
+
+        return ObjectId(value)
+
+    @classmethod
+    def __modify_schema__(cls, field_schema):
+        field_schema.update(type="string")

pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"

requirements_test.txt

@@ -0,0 +1,12 @@
+mock
+coverage==5.2.1
+flake8==3.8.3
+phulpy==1.0.10
+pytest==5.4.3
+pytest-cov==2.10.0
+pytest-mock==3.2.0
+mongomock==3.23.0
+pydantic==1.8.2
+pymongo==3.12.0
+mypy==0.910
+mypy-extensions==0.4.3

setup.cfg

@@ -0,0 +1,2 @@
+[bdist_wheel]
+universal = 1

setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup
+
+long_description = open('README.rst', 'r').read()
+
+setup(
+    name='pydantic-mongo',
+    version='0.0.1',
+    packages=['pydantic_mongo'],
+    setup_requires=['wheel'],
+    install_requires=[
+        'pymongo>=3.12,<4.0',
+        'pydantic>=1.6.2,<2.0.0'
+    ],
+    entry_points={
+        "console_scripts": [
+            "pydantic_mongo = pydantic_mongo.__main__:__main__"
+        ],
+    },
+    description="Document object mapper for pydantic and pymongo",
+    long_description=long_description,
+    url='https://github.com/jefersondaniel/pydantic-mongo',
+    author='Jeferson Daniel',
+    author_email='[email protected]',
+    license='MIT',
+    classifiers=[
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python :: 3',
+    ],
+    python_requires=">=3.6"
+)

test/__init__.py

@@ -0,0 +1,38 @@
+import pytest
+from bson import ObjectId
+from pydantic_mongo import ObjectIdField
+from pydantic import BaseModel
+from pydantic.error_wrappers import ValidationError
+
+
+class User(BaseModel):
+    id: ObjectIdField = None
+
+    class Config:
+        json_encoders = {ObjectId: str}
+
+
+class TestFields:
+    def test_object_id_validation(self):
+        with pytest.raises(ValidationError):
+            User.parse_obj({'id': 'lala'})
+        User.parse_obj({'id': '611827f2878b88b49ebb69fc'})
+
+    def test_object_id_serialize(self):
+        lala = User(id=ObjectId('611827f2878b88b49ebb69fc'))
+        json_result = lala.json()
+        assert '{"id": "611827f2878b88b49ebb69fc"}' == json_result
+
+    def test_modify_schema(self):
+        user = User(id=ObjectId('611827f2878b88b49ebb69fc'))
+        schema = user.schema()
+        assert {
+            'title': 'User',
+            'type': 'object',
+            'properties': {
+                'id': {
+                    'title': 'Id',
+                    'type': 'string'
+                }
+            }
+        } == schema