Metadata-Version: 1.1
Name: mokito
Version: 0.3.8
Summary: Mokito is an asynchronous ORM for working with MongoDB inside a Tornado app
Home-page: https://github.com/Asmodius/mokito
Author: Asmodius
Author-email: asmodius.a@gmail.com
License: New BSD License
Download-URL: https://github.com/Asmodius/mokito/archive/master.zip
Description: # mokito
        An asynchronous ORM for accessing MongoDB in Tornado
        
        ## What is mokito?
        (MOngodb + [mongoKIt](https://github.com/namlook/mongokit) + TOrnado) is an asynchronous toolkit for working with ``mongodb`` inside a ``tornado`` app, like ``mongokit``. Mokito has a pure implementation of python + tornado and only depends on tornado and bson (provided by pymongo)
        
        ## Why not pymongo?
        [PyMongo](http://api.mongodb.org/python/current/) is the recommended way to work with MongoDB in Python, but isn't asynchronous and not run inside tornado's IOLoop. If you use pymongo you won't take the advantages of tornado.
        
        ## Why not motor?
        [Motor](http://emptysquare.net/motor/) wraps PyMongo and makes it async with greenlet. This is a great project, but it uses greenlet. If you can use greenlets why not use gevent instead of tornado? PyMongo already works with gevent. If you are using a very powerfull non-blocking web server with a pure python code, you'll probably want to work with a pure tornado driver for accessing mongo.
        
        ## Features
        * validation and conversion of data to the specified type
        * support for unstructured data
        * dot notation
        * control over data presentation
        * control over data validation
        * mapping onto the same document of models with different schemes
        
        ## Installing
        ```bash
        pip install pymomgo tornado
        pip install mokito
        ```
        
        ## Simple usage
        ```python
        from tornado.web import RequestHandler
        from tornado.gen import coroutine
        
        import mokito
        
        
        class MainHandler(RequestHandler):
        
            def initialize(self):
                self.db = mokito.Client("db_name", "mongodb://127.0.0.1:27017")
        
            @gen.coroutine
            def get(self, user_id):
                user = yield self.db.user.find_one(user_id)
                self.render("index.html", user=user)
        ```
        
        ## Using ORM
        A Document declaration look as follows:
        
        ```python
        from mokito import Document
        
        class BlogPost(Document):
            fields = {
                'title':str,
                'body':str,
                'author':str
            }
        
        blogpost = BlogPost(title='my title', body='a body', author='unknown', foo='bar')
        blogpost['author'] = 'me'
        yield blogpost.save()
        ```
        MongoDB in the collection "blog_post" will write this document:
        ```javascript
        {"_id": ObjectId("..."), "body": "a body", "author": "me", "title": "my title"}
        ```
        The field "foo" will not be saved. More about this you can read in [wiki](https://github.com/asmodius/mokito/wiki).
        
        And you can use a more complex structure as follows:
        ```python
        class ComplexDoc(Document):
            __uri__ = "mongodb://127.0.0.1:27017"
            __database__ = 'test'
            __collection__ = 'example'
        
            fields = {
                "f_1": None,
                "f_2": int,
                "f_3": float,
                "f_4": dict,
                "f_5": [str],
                "f_6": (int, str),
                "f_7": {
                    "x_1": {'a': int, 'b': datetime.datetime},
                    "x_2": None,
                    "x_3": list
                }
            }
        ```
        
        Please see the [wiki](https://github.com/asmodius/mokito/wiki) for more examples.
        
Keywords: mongo mongodb tornado mokito
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved
Classifier: Operating System :: POSIX :: Linux
Classifier: Programming Language :: Python :: 3.6
Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
