def make_jsonapi(app): jsonapi = JsonApi(app=app) jsonapi.route(SubstanceList, "substance_list", f"{api_versioning_v1}/substances") jsonapi.route(SubstanceResource, "substance_detail", f"{api_versioning_v1}/substances/<id>") jsonapi.route( SubstanceIndexResource, "substance_index", f"{api_versioning_v1}/substances/_index", ) jsonapi.route( SubstanceSearchResultList, "resolved_substance_list", f"{api_versioning_v1}/resolver", )
def create_flask_app(): app = Flask(__name__) app.config.from_mapping( SQLALCHEMY_DATABASE_URI= f'postgresql://{os.environ["POSTGRES_USER"]}:{os.environ["POSTGRES_PASSWORD"]}' f'@{os.environ["POSTGRES_URL"]}/{os.environ["POSTGRES_DB"]}') from .db import db, migrate app.config.from_json('../config.json') db.init_app(app) migrate.init_app(app, db) from .views import IncidentsList, IncidentsDetail api = Api(app) api.route(IncidentsList, 'incidents_list', '/incidents') api.route(IncidentsDetail, 'incidents_detail', '/incidents/<int:id>') return app
def create_app(**config): app = Flask(__name__) from . import cli app.cli.add_command(cli.tasks) app.config['SQLALCHEMY_DATABASE_URI'] = 'postgres://localhost/tasks_dev' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False app.config.update(config) if 'DATABASE_URL' in os.environ: app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DATABASE_URL'] from .extensions import db db.init_app(app) from .resources import TaskDetail, TaskList api = Api(app) api.route(TaskList, 'task_list', '/tasks') api.route(TaskDetail, 'task_detail', '/tasks/<uuid:id>') return app
}, } class ComputerDetail(ResourceDetail): schema = ComputerSchema data_layer = {"session": db.session, "model": Computer} class ComputerRelationship(ResourceRelationship): schema = ComputerSchema data_layer = {"session": db.session, "model": Computer} # Create endpoints api = Api(app) api.route(PersonList, "person_list", "/persons") api.route( PersonDetail, "person_detail", "/persons/<int:id>", "/computers/<int:computer_id>/owner", ) api.route(PersonRelationship, "person_computers", "/persons/<int:id>/relationships/computers") api.route(ComputerList, "computer_list", "/computers", "/persons/<int:id>/computers") api.route(ComputerDetail, "computer_detail", "/computers/<int:id>") api.route(ComputerRelationship, "computer_person", "/computers/<int:id>/relationships/owner")
def create_app(config_filename=None, host="localhost"): app = Flask(__name__) # app.config.update(SQLALCHEMY_DATABASE_URI="sqlite://") app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///test.db" db.init_app(app) api = Api(app) api.route(PersonList, "person_list", "/persons") api.route( PersonDetail, "person_detail", "/persons/<int:id>", "/computers/<int:id>/owner" ) api.route( PersonRelationship, "person_computers", "/persons/<int:id>/relationships/computers", ) api.route( ComputerList, "computer_list", "/computers", "/persons/<int:person_id>/computers", ) api.route(ComputerDetail, "computer_detail", "/computers/<int:id>") api.route( ComputerRelationship, "computer_person", "/computers/<int:id>/relationships/owner", ) with app.app_context(): db.create_all() create_api(app, host) return app
id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) db.create_all() class EntrySchema(Schema): class Meta: type_ = 'entry' self_view = 'entry_one' self_view_kwargs = {'id': '<id>'} self_view_many = 'entry_many' id = fields.Integer() name = fields.Str(required=True) class EntryMany(ResourceList): schema = EntrySchema data_layer = {'session': db.session, 'model': Entry} class EntryOne(ResourceDetail): schema = EntrySchema data_layer = {'session': db.session, 'model': Entry} api = Api(app) api.route(EntryMany, 'entry_many', '/entries') api.route(EntryOne, 'entry_one', '/entries/<int:id>') if __name__ == '__main__': app.run(debug=True)
self_view_kwargs = {'id': '<id>'} self_view_many = 'artist_many' id = fields.Integer() name = fields.Str(required=True) birth_year = fields.Integer(load_only=True) genre = fields.Str() # Create resource managers and endpoints from flask_rest_jsonapi import Api, ResourceDetail, ResourceList class ArtistMany(ResourceList): schema = ArtistSchema data_layer = {'session': db.session, 'model': Artist} class ArtistOne(ResourceDetail): schema = ArtistSchema data_layer = {'session': db.session, 'model': Artist} api = Api(app) api.route(ArtistMany, 'artist_many', '/artists') api.route(ArtistOne, 'artist_one', '/artists/<int:id>') # main loop to run app in debug mode if __name__ == '__main__': app.run(debug=True)
# # Create resource managers class PersonList(ResourceList): # def query(self, view_kwargs): # query_ = self.session.query(CompanyModel) # return query_ schema = PersonSchema data_layer = {'session': db.session, 'model': CompanyModel} # class PersonDetail(ResourceDetail): # schema = PersonSchema # data_layer = {'session': db.session, # 'model': CompanyModel} # # Create endpoints api = Api(app) api.route(PersonList, 'person_list', '/personsapi') #api.route(PersonDetail, 'person_detail', '/personsapi/<int:id>') # api.route(PersonRelationship, 'person_computers', '/persons/<int:id>/relationships/computers') # api.route(ComputerList, 'computer_list', '/computers', '/persons/<int:id>/computers') # api.route(ComputerDetail, 'computer_detail', '/computers/<int:id>') # api.route(ComputerRelationship, 'computer_person', '/computers/<int:id>/relationships/owner') # def J(*args, **kwargs): # """Wrapper around jsonify that sets the Content-Type of the response to # application/vnd.api+json. # """ # response = jsonify(*args, **kwargs) # response.mimetype = 'application/vnd.api+json' # return response #
} class AdDetail(ResourceDetail): schema = AdSchema data_layer = {'session': db.session, 'model': Ad} class AdRelationship(ResourceRelationship): schema = AdSchema data_layer = {'session': db.session, 'model': Ad} # Create endpoints api = Api(app) api.route(PersonList, 'person_list', '/persons') api.route(PersonDetail, 'person_detail', '/persons/<int:id>', '/ads/<int:ad_id>/created_by') api.route(PersonRelationship, 'person_ads', '/persons/<int:id>/relationships/ads') api.route(AdList, 'ad_list', '/ads', '/persons/<int:id>/ads') api.route(AdDetail, 'ad_detail', '/ads/<int:id>') api.route(AdRelationship, 'ad_person', '/ads/<int:id>/relationships/created_by') @app.route('/') def index(): return "Hello !"
reserved_one = fields.Str() reserved_two = fields.Str() reserved_three = fields.Str() reserved_four = fields.Str() created_time = fields.DateTime() updated_time = fields.DateTime() class USBInstallList(ResourceList): schema = USBInstallSchema data_layer = { 'session' : db.session, 'model' : USBInstall } class USBInstallDetail(ResourceDetail): schema = USBInstallSchema data_layer = { 'session' : db.session, 'model' : USBInstall } api = Api(dt_flask) api.route(USBInstallList, 'usbinstall_list', '/api/v1/usbinstall') api.route(USBInstallDetail, 'usbinstall_detail', '/api/v1/usbinstall/<int:id>') @dt_flask.route('/api/v1/add_from_app', methods = ['POST',]) def insert_db_record_from_app(): def request_json_looks_good(request_json): return True def create_usb_install_object(request_json, right_here_right_now): new_record = USBInstall(status="New", fiery_iso=request_json["fiery_iso"], osiso_one=request_json["osiso_one"],osiso_two=request_json["osiso_two"],usersw_iso=request_json["usersw_iso"],product_name=request_json["product_name"],created_time=right_here_right_now, updated_time=datetime.now()) try: new_record.adobe_iso = request_json["adobe_iso"] except: pass
from commandment.pki.models import RSAPrivateKey, CertificateSigningRequest from commandment.dep.models import DEPServerTokenCertificate, DEPAccount from commandment.enroll.util import generate_enroll_profile from commandment.cms.decorators import verify_cms_signers from commandment.plistutil.nonewriter import dumps as dumps_none from commandment.profiles.plist_schema import ProfileSchema from commandment.profiles import PROFILE_CONTENT_TYPE from commandment.pki.ca import get_ca from commandment.dep import smime from .resources import DEPProfileList, DEPProfileDetail, DEPProfileRelationship, DEPAccountList, DEPAccountDetail import plistlib import json dep_app = Blueprint('dep_app', __name__) api = Api(blueprint=dep_app) api.route(DEPProfileList, 'dep_profiles_list', '/api/v1/dep/profiles/', '/api/v1/dep/accounts/<int:dep_account_id>/profiles') api.route(DEPProfileDetail, 'dep_profile_detail', '/api/v1/dep/profiles/<int:dep_profile_id>') api.route(DEPProfileRelationship, 'dep_profile_devices', '/api/v1/dep/profiles/<int:dep_profile_id>/relationships/devices') api.route( DEPProfileRelationship, 'dep_profile_dep_account', '/api/v1/dep/profiles/<int:dep_profile_id>/relationships/dep_account') api.route(DEPAccountList, 'dep_accounts_list', '/api/v1/dep/accounts/') api.route(DEPAccountDetail, 'dep_account_detail', '/api/v1/dep/accounts/<int:dep_account_id>')
polar_angle = fields.Decimal(validate = validate.Range(min=0,max=1)) class PulseList(ResourceList): schema = PulseSchema data_layer = {'session': db.session, 'model': Pulse} class PulseDetail(ResourceDetail): schema = PulseSchema data_layer = {'session': db.session, 'model': Pulse } @app.route("/",methods=['GET']) def hellow(): return "hello world" @app.route("/pulses/download") def downloadpulses(): print("downloading pulses") api = Api(app) api.route(PulseList,'pulses_list','/pulses') api.route(PulseDetail,'pulse_detail','/pulses/<int:id>') if __name__ == "__main__": app.run(debug=True)
APP = Flask(__name__, template_folder='templates') APP.config.from_object(config) # app.config.from_envvar('YOURAPPLICATION_SETTINGS') APP.config.update( dict( SQLALCHEMY_DATABASE_URI='sqlite:///' + os.path.join(_BASEDIR, 'bump.db'), DATABASE_CONNECT_OPTIONS={}, SQLALCHEMY_TRACK_MODIFICATIONS=False, )) DB = SQLAlchemy(APP) CORS(APP) api = Api(APP) # oauth2 = OAuth2Provider(APP) # class MyValidator(OAuth2RequestValidator): # def authenticate_client_id(client_id, request, *args, **kwargs): # request.client.client_id = client_id # def authenticate_client(request, *args, **kwargs): # request.client.client_id = 'test' # import bump.auth # from bump.auth import load_client, load_token, load_grant # oauth2._validator = MyValidator(load_client, load_token, load_grant) # api.oauth_manager(oauth2)
class PlayerOne(ResourceDetail): schema = PlayerSchema data_layer = {'session': db.session, 'model': Player} class RoleMany(ResourceList): schema = RoleSchema data_layer = {'session': db.session, 'model': Role} class RoleOne(ResourceDetail): schema = RoleSchema data_layer = {'session': db.session, 'model': Role} class PlayerRole(ResourceRelationship): schema = PlayerSchema data_layer = {'session': db.session, 'model': Player} api = Api(app) api.route(PlayerMany, 'player_many', '/players') api.route(PlayerOne, 'player_one', '/players/<int:id>') api.route(RoleOne, 'role_one', '/roles/<int:id>') api.route(RoleMany, 'role_many', '/roles') api.route(PlayerRole, 'player_roles', '/players/<int:id>/relationships/roles') if __name__ == '__main__': app.run(debug=True)
from flask import current_app as app, Blueprint from flask_rest_jsonapi import Api from app.api.helpers.permission_manager import permission_manager api_v1 = Blueprint('v1', __name__, url_prefix='/v1') api = Api(app, api_v1) api.permission_manager(permission_manager)
# -*- coding: utf-8 -*- from flask import Flask from flask_rest_jsonapi import Api, ResourceDetail app = Flask(__name__) api = Api(app) class HelloWorld(ResourceDetail): def get(self): return "Hello world" api.detail_route('index', '/', resource_cls=HelloWorld) if __name__ == '__main__': app.run(debug=True)
from flask import Blueprint from flask_rest_jsonapi import Api from commandment.profiles.resources import ProfilesList, ProfileDetail, ProfileRelationship profiles_api_app = Blueprint('profiles_api', __name__) api = Api(blueprint=profiles_api_app) # Profiles (Different to profiles returned by inventory) api.route(ProfilesList, 'profiles_list', '/v1/profiles') api.route(ProfileDetail, 'profile_detail', '/v1/profiles/<int:profile_id>') api.route(ProfileRelationship, 'profile_tags', '/v1/profiles/<int:profile_id>/relationships/tags') # api.route(PayloadsList, 'payloads_list', '/v1/payloads') # api.route(PayloadDetail, 'payload_detail', '/v1/payloads/<int:payload_id>')
schema = SettingsSchema data_layer = {'session': db.session, 'model': Settings} class EntitiesList(ResourceList): schema = EntitiesSchema data_layer = {'session': db.session, 'model': Entities} class EntitiesDetail(ResourceDetail): schema = EntitiesSchema data_layer = {'session': db.session, 'model': Entities} # Create the API object api = Api(app) api.route(SettingsList, 'setting_list', '/api/settings') api.route(SettingsDetail, 'setting_detail', '/api/settings/<int:id>') api.route(EntitiesList, 'entity_list', '/api/entities') api.route(EntitiesDetail, 'entity_detail', '/api/entities/<int:id>') @app.route('/') def send_index(): return send_from_directory('web/dist/', 'index.html') @app.route('/css/<path:path>') def send_css(path): return send_from_directory('web/dist/css', path)
class RecordOne(ResourceDetail): schema = RecordSchema data_layer = {'session': db.session, 'model': Record} class UserRecord(ResourceRelationship): schema = UserSchema data_layer = {'session': db.session, 'model': User} class TournRecord(ResourceRelationship): schema = TournSchema data_layer = {'session': db.session, 'model': Tourn} api = Api(app) api.route(UserMany, 'user_many', '/users') api.route(UserOne, 'user_one', '/users/<int:id>') api.route(TournMany, 'tourn_many', '/tourns') api.route(TournOne, 'tourn_one', '/tourns/<int:id>') api.route(RecordOne, 'record_one', '/records/<int:id>') api.route(RecordMany, 'record_many', '/records') api.route(UserRecord, 'user_records', '/users/<int:id>/relationships/records') api.route(TournRecord, 'tourn_records', '/tourns/<int:id>/relationships/records') # main loop to run app in debug mode if __name__ == '__main__': app.secret_key = 'test' app.run(host=str(get_info(2)), port=int(get_info(3)), debug=False)
from flask import Blueprint, request from flask_rest_jsonapi import Api from commandment.apps.resources import ApplicationDetail, ApplicationList, ApplicationRelationship, \ ManagedApplicationList, ManagedApplicationDetail, ManagedApplicationRelationship, MASApplicationList, \ MASApplicationDetail, IOSApplicationList, IOSApplicationDetail api_app = Blueprint('applications_api', __name__) api = Api(blueprint=api_app) api.route(ApplicationList, 'applications_list', '/v1/applications') api.route(ApplicationDetail, 'application_detail', '/v1/applications/<int:application_id>') api.route(ApplicationRelationship, 'application_tags', '/v1/applications/<int:application_id>/relationships/tags') api.route(ManagedApplicationList, 'managed_applications_list', '/v1/managed_applications', '/v1/applications/<int:application_id>/managed_applications') api.route(ManagedApplicationDetail, 'managed_application_detail', '/v1/managed_applications/<int:managed_application_id>') api.route(ManagedApplicationRelationship, 'managed_application_device', '/v1/managed_applications/<int:application_id>/relationships/device') # Platform specific subclasses api.route(MASApplicationList, 'mas_applications_list', '/v1/applications/store/mac') api.route(MASApplicationDetail, 'mas_application_detail', '/v1/applications/store/mac/<int:application_id>') api.route(IOSApplicationList, 'ios_applications_list',
artist_id = fields.Integer(required=True) class ArtworkMany(ResourceList): schema = ArtworkSchema data_layer = {'session': db.session, 'model': Artwork} class ArtworkOne(ResourceDetail): schema = ArtworkSchema data_layer = {'session': db.session, 'model': Artwork} class ArtistArtwork(ResourceRelationship): schema = ArtistSchema data_layer = {'session': db.session, 'model': Artist} api = Api(app) api.route(ArtworkOne, 'artwork_one', '/artworks/<int:id>') api.route(ArtworkMany, 'artwork_many', '/artworks') api.route(ArtistArtwork, 'artist_artworks', '/artists/<int:id>/relationships/artworks') # main loop to run app in debug mode if __name__ == '__main__': # Create the table db.create_all() app.run(debug=True)
class PriorityDetail(ResourceDetail): schema = PrioritySchema data_layer = {'session': db.session, 'model': Priority} class FeatureRequestDetail(ResourceDetail): schema = FeatureRequestSchema data_layer = {'session': db.session, 'model': FeatureRequest} class FeatureRequestList(ResourceList): schema = FeatureRequestSchema data_layer = {'session': db.session, 'model': FeatureRequest} # Create endpoints api = Api(app) api.route(ClientList, 'client_list', '/clients') api.route(ClientDetail, 'client_detail', '/clients/<int:id>') api.route(ProductAreaList, 'product_area_list', '/product_areas') api.route(ProductAreaDetail, 'product_area_detail', '/product_areas/<int:id>') api.route(PriorityList, 'priority_list', '/priorities') api.route(PriorityDetail, 'priority_detail', '/priorities/<int:id>') api.route(FeatureRequestList, 'feature_request_list', '/feature_requests') api.route(FeatureRequestDetail, 'feature_request_detail', '/feature_requests/<int:id>') if __name__ == '__main__': # Start application app.run(debug=True)
} } class ComputerDetail(ResourceDetail): schema = ComputerSchema data_layer = {'session': db.session, 'model': Computer} class ComputerRelationship(ResourceRelationship): schema = ComputerSchema data_layer = {'session': db.session, 'model': Computer} # Create endpoints api = Api(app) api.route(PersonList, 'person_list', '/persons') api.route(PersonDetail, 'person_detail', '/persons/<int:id>', '/computers/<int:computer_id>/owner') api.route(PersonRelationship, 'person_computers', '/persons/<int:id>/relationships/computers') api.route(ComputerList, 'computer_list', '/computers', '/persons/<int:id>/computers') api.route(ComputerDetail, 'computer_detail', '/computers/<int:id>') api.route(ComputerRelationship, 'computer_person', '/computers/<int:id>/relationships/owner') if __name__ == '__main__': # Start application app.run(debug=True)
from flask import Blueprint from flask import current_app as app from flask_rest_jsonapi import Api from app.api.helpers.permission_manager import permission_manager api_v1 = Blueprint('v1', __name__, url_prefix='/v1') api = Api(app, api_v1) api.permission_manager(permission_manager)
from flask import Blueprint, current_app from flask import jsonify from flask_rest_jsonapi import Api from web_service.lib.errors import PermissionDenied from web_service.api.permissions import permission_manager api_bp = Blueprint('api', __name__, url_prefix='/api') api = Api(blueprint=api_bp) api.permission_manager(permission_manager) @current_app.errorhandler(PermissionDenied) def handle_invalid_usage(error): response = jsonify(error.to_dict()) response.status_code = error.status_code return response
from commandment.models import db, RSAPrivateKey, CertificateSigningRequest from commandment.dep.models import DEPServerTokenCertificate, DEPAccount from commandment.enroll.util import generate_enroll_profile from commandment.cms.decorators import verify_cms_signers from commandment.plistutil.nonewriter import dumps as dumps_none from commandment.profiles.plist_schema import ProfileSchema from commandment.profiles import PROFILE_CONTENT_TYPE from commandment.pki.ca import get_ca from commandment.dep import smime from .resources import DEPProfileList, DEPProfileDetail, DEPProfileRelationship import plistlib import json dep_app = Blueprint('dep_app', __name__) api = Api(blueprint=dep_app) api.route(DEPProfileList, 'dep_profile_list', '/v1/dep/profiles/') api.route(DEPProfileDetail, 'dep_profile_detail', '/v1/dep/profiles/<int:dep_profile_id>') api.route(DEPProfileRelationship, 'dep_profile_devices', '/v1/dep/profiles/<int:dep_profile_id>/relationships/devices') @dep_app.route('/v1/dep/account', methods=["GET"]) def account(): pass @dep_app.route('/dep/certificate/download', methods=["GET"]) def certificate_download():
data_layer = {'session': db.session, 'model': Review, 'methods': {'query': query, 'before_create_object': before_create_object}} class ReviewDetail(ResourceDetail): schema = ReviewSchema data_layer = {'session': db.session, 'model': Review} class ReviewRelationship(ResourceRelationship): schema = ReviewSchema data_layer = {'session': db.session, 'model': Review} # Create endpoints api = Api(app) api.route(BookList, 'book_list', '/books') api.route(BookDetail, 'book_detail', '/books/<int:id>', '/reviews/<int:review_id>/book') api.route(BookRelationship, 'book_reviews', '/books/<int:id>/relationships/reviews') api.route(ReviewList, 'review_list', '/reviews', '/books/<int:id>/reviews') api.route(ReviewDetail, 'review_detail', '/reviews/<int:id>') api.route(ReviewRelationship, 'review_book', '/reviews/<int:id>/relationships/book') if __name__ == '__main__': # Start application app.run(debug=True)
dialect_type = dialect.type_descriptor(CHAR(32)) return dialect_type def process_bind_param(self, value, dialect): if value is None: result = value elif dialect.name == 'postgresql': result = str(value) else: if not isinstance(value, uuid.UUID): result = "%.32x" % uuid.UUID(value).int else: # hexstring result = "%.32x" % value.int return result def process_result_value(self, value, dialect): if value is None: result = value else: if not isinstance(value, uuid.UUID): result = uuid.UUID(value) return result DB = SQLAlchemy() API = Api()
from product_api import app, db from product_api.models import Product from flask_rest_jsonapi import Api, ResourceList, ResourceDetail from marshmallow_jsonapi import fields from marshmallow_jsonapi.flask import Schema api = Api(app) class ProductSchema(Schema): class Meta: type_ = 'product' self_view = 'product_detail' self_view_kwargs = {'id': '<id>'} self_view_many = 'products' id = fields.Integer(as_string=True, dump_only=True) name = fields.Str(required=True, dump_only=True) class ProductList(ResourceList): schema = ProductSchema data_layer = {'session': db.session, 'model': Product} class ProductDetail(ResourceDetail): schema = ProductSchema data_layer = {'session': db.session, 'model': Product} api.route(ProductList, 'products', '/products')
type_values = fields.Dict() weaknesses = fields.Dict() # Create resource managers and endpoints class PokemonMany(ResourceList): schema = PokemonSchema data_layer = {'session': db.session, 'model': Pokemon} class PokemonOne(ResourceDetail): schema = PokemonSchema data_layer = {'session': db.session, 'model': Pokemon} api = Api(app) api.route(PokemonMany, 'pokemon_many', '/pokemon') api.route(PokemonOne, 'pokemon_one', '/pokemon/<int:id>') @app.route("/pokemon/<string:name>") def user_detail(name): schema = PokemonSchema() p = Pokemon.query.filter_by(name=name).first() pdict = schema.dump(p) print(pdict) return pdict
print( "# apt install python3-flask python3-flask-socketio python3-libvirt python3-prctl" ) print("$ pip3 install flask_rest_jsonapi") raise from lib.Resources import HypervisorsList, HypervisorDetail, HypervisorRelationship from lib.Resources import VirtualMachineList, VirtualMachineDetail, VirtualMachineRelationship from lib.LibVirt import LibVirtMonitorInstance from lib.LibVirtData import libvirt_data app = Flask(__name__) app.config['SECRET_KEY'] = 'SGVsbG8sIHdvcmxkIQ==' app.config['DEBUG'] = True api = Api(app) # ~ socketio = SocketIO(app) api.route(HypervisorsList, 'hypervisors_list', '/hypervisors') api.route(HypervisorDetail, 'hypervisor_detail', '/hypervisors/<int:id>', '/virtual-machines/<string:virtual_machine_id>/hypervisor') api.route(HypervisorRelationship, 'hypervisor_virtual_machines', '/hypervisors/<int:id>/relationships/virtual-machines') api.route(VirtualMachineList, 'virtual_machine_list', '/virtual-machines', '/hypervisors/<int:id>/virtual-machines') api.route(VirtualMachineDetail, 'virtual_machine_detail', '/virtual-machines/<string:id>') api.route(VirtualMachineRelationship, 'virtual_machine_hypervisor', '/virtual-machines/<string:id>/relationships/hypervisor')