Package: discoverpy
REST service framework for discoverable services.Writing RESTful services can be repetitive. Every new resource in an API
requires that you pick a URL route, write code to validation data, write a
request handler endpoint, convert your data to something which can be JSON
encoded, JSON encode your data view, add pagination, set all the right headers,
and return the proper response codes. Then you have write a new HTTP client,
create object representation of your REST resources, and handle all your
chosen HTTP response codes. Finally, you get a change to integrate your new
service into the code where you actually wanted it by using your Python client
or hacking it up on the CLI.This project takes all of that boilerplate work and automates it. You focus
on the important parts of managing your resource data and integrating the
service into your other code. We handle the REST.Quick Examplefromdiscoverpy.applicationimportApplicationfromdiscoverpy.serviceimportServicefromdiscoverpy.resources.readonlyimportReadOnlyResourceclassHelloWorldResource(ReadOnlyResource):hellos=[{"name":"world"},{"name":"hello"}]identifier="name"defget(self,query,identifier):return{"name":identifier,}defload(self,query):returnself.hellosservice=Service(name="greeting",description="A service for greeting people and machines.",version="1",)service.add(HelloWorldResource(name="hello",description="Greet a person or machine with hello.",))app=Application(services=[service])Now run the service under any WSGI server and request away.# Get a paginated list of resources.curl"localhost:8888/greeting/v1/hello"# Get an instance of a resource.curl"localhost:8888/greeting/v1/hello/you"# See your new service in the API discovery service.curl"localhost:8888/discover/v1/service?name=greeting"curl"localhost:8888/discover/v1/resource?service=greeting&version=1"The example is degenerate, but the principle should visible: You don’t have to
deal with boilerplate. Implementing a resource class which can manage your data
is sufficient and the framework will handle the HTTP bits.Service Discovery APIThe namesake of the project is rooted in the automatic service discovery API
which is generated with each WSGI application. It uses the metadata given
when you create Service or Resource objects to construct an API which allows
consumers to see what services your endpoint provides, what resources are
exposed by those services, and the JSON schema used to validate input.The service discovery API works as follows:GET /discover/v1/serviceGet a paginated list of all services registered with the WSGI application.GET /discover/v1/service/{service name}?version={service version}Get an instance of a service.GET /discover/v1/resource?service={service name}&version={service version}Get a paginated list of resources registered with the service.GET /discover/v1/resource/{resource name}?service={service name}&version={service version}Get an instance of a resource.This API is used to power the automatic client.Automatic ClientThe project ships with a Python client which leverages the service discovery
API to automatically provide an interface to new services and resources.fromdiscoverpy.client.apiimportClientclient=Client(endpoint='http://localhost:8888')# Iterate over all services and resources.forserviceinclient.services:print('name:{0}, version:{1}, description:{2}'.format(service.name,service.version,service.description,))forresourceinservice.resources:print('name:{0}, description:{1}'.format(resource.name,resource.description,))# Get a specific resource and iterate over its paginated output.resource=client.service('greeting',version='1').resource('hello')forhelloinresource.load():print('name:{0}'.format(hello.name))Resource ClassesThere is a base Resource class which can be extended, but resources can be any
Python object which expose the following signatures:identifierThe field name of the resource identifier in a payload.nameThe name of the resource.descriptionThe description of the resource.validatorThe JSON schema validator to use with the resource.load(query)Return a two-tuple where the first element is the paginated content
and the second is the total number of items which match the query.get(query, identifier)Return a single resource matching the query.create(query, data)Create a new resource and return it.update(query, identifier, data)Update an instance and return the new data.delete(query, identifier)Delete the given resourceThe get, load, create, update, and delete methods should return Python
dictionaries which can be JSON encoded. In each method the query parameter will
be a special Query object which wraps a URL query string for easier management,
the identifier will the the last portion of a URL, and data will be a Python
dictionary which was decoded from JSON input.Any complete implementation of the Resource interface may be passed to the
Service object. There are built in versions of Resource which provide some
handy features.The resources.readonly.ReadOnlyResource allows subclasses to only implement
get and load. It will handle the other methods appropriately. The
resources.sqlalchemy.SqlalchemyResource allows you to pass in a SQLAlchemy ORM
model and generate an API around it. Look at the SqlalchemyResource as an
example for how complex resources may be implemented.License(MIT License)

Copyright (C) 2015 Kevin Conway

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.ContributingAll contributions to this project are protected under the agreement found in
theCONTRIBUTINGfile. All contributors should read the agreement but, as
a summary:You give us the rights to maintain and distribute your code and we promise
to maintain an open source distribution of anything you contribute.