Metadata-Version: 1.0
Name: pillowtalk
Version: 1.0.alpha
Summary: Intuitive API wrapper framework using marshmallow
Home-page: https://github.com/jvrana/pillowtalk
Author: Justin Dane Vrana
Author-email: justin.vrana@gmail.com
License: MIT
Description: |travis build| |Coverage Status|
        
        |pillow\_talk\_icon| # **Pillowtalk**
        
        Creates intuitive python wrappers for APIs. **Pillowtalk** talks to APIs
        and handles all of the model relationships behind the scenes, providing
        a clean and easy-to-use wrapper for your models.
        
        Why another package?
        ====================
        
        While there are plenty of excellent libraries for creating APIs, but
        creating intuitive wrappers for these APIs isn't entirely
        straightforward. **Pillowtalk** cleanly captures the underlying database
        relationships APIs may be providing making it easy to write python
        models. It provides a wrapper for making intuitive live API calls using
        your python models and the underlying relationships you specified.
        
        In future versions, **pillowtalk** will be able to create and update
        your code based on a list of JSON files and *guess* at the underlying
        relationships between models. From there, **pillowtalk** will
        automatically generate or update python models. This means changes to
        some API can trigger an automatic update to your python wrapper to that
        API!
        
        Features and Examples
        =====================
        
        Minimalistic models with relationships
        --------------------------------------
        
        e.g. Person with ONE Address; Address has MANY people
        
        .. code:: python
        
            class MyBase(PillowtalkBase):
                @classmethod
                def find(cls, id):
                     ...
                     
                def where(cls, data):
                     ...
        
            @add_schema
            class Person(MyBase):
                FIELDS = ["id", "name"]
                RELATIONSHIPS = [
                  One("address", "find Person.address_id <> Address.id")
                ]
                  
            @add_schema
            class Address(MyBase):
                FIELDS = ["id", "str"]
                RELATIONSHIPS = [
                  Many("people", "where Address.id <> Person.address_id")
                ]
        
        Intuitive calls uses live API connection to deserialize data to your
        models
        
        .. code:: python
        
            # address.people doesn't exist yet
            address = Address.find(3)
        
            # calling .people causes a api call using "where" and deserialization of data
            people = address.people # returns a list of People objects found through "where"
        
            # returned is a list of Person objects!
            assert type(people[0]) is Person 
        
        Handling impartial data
        
        .. code:: python
        
            person = {
              "id": 5,
              "name": "Joe",
              "address": {"id": 4}
            }
        
            p = Person.load(person_data)
        
            # a.address will magically return Address object even though data is enveloped in a json.
            # we do not specifically have to handle deserialization of impartial data since the
            # relationship between Person.address_id <> Address.id was already defined.
            a = p.address
            assert type(a) is Address
            assert person.address_id == 4 # this wasn't defined explicitly but it is inferred from "address": {"id": 4}
        
        More examples and magic to come!
        --------------------------------
        
        ::
        
            Other things include:
                * Magic chaining in relationships
                * Session managing suggestions
                * automatically creating model skeletons from list of JSON
                * model relationships through associations
                * examples of connecting to MySQL or SQLlite
                * examples of using CLI through hug
                
        
        .. |travis build| image:: https://img.shields.io/travis/jvrana/**Pillowtalk**.svg
           :target: https://travis-ci.org/jvrana/**Pillowtalk**
        .. |Coverage Status| image:: https://coveralls.io/repos/github/jvrana/**Pillowtalk**/badge.svg?branch=master
           :target: https://coveralls.io/github/jvrana/**Pillowtalk**?branch=master
        .. |pillow\_talk\_icon| image:: images/pillowtalk_icon_medium.png?raw=true
        
        
Keywords: serialization marshmallow deserialization orm api-wrapper api
Platform: UNKNOWN
