예제 #1
0
    def test_marshal_with_handle_polymorph(self, app, client):
        api = Api(app)

        parent = api.model('Person', {
            'name': fields.String,
        })

        child1 = api.inherit('Child1', parent, {
            'extra1': fields.String,
        })

        child2 = api.inherit('Child2', parent, {
            'extra2': fields.String,
        })

        class Child1(object):
            name = 'child1'
            extra1 = 'extra1'

        class Child2(object):
            name = 'child2'
            extra2 = 'extra2'

        mapping = {Child1: child1, Child2: child2}

        thing = api.model('Thing', {
            'owner': fields.Polymorph(mapping),
        })

        @api.route('/thing-1/')
        class Thing1Resource(Resource):
            @api.marshal_with(thing)
            def get(self):
                return {'owner': Child1()}

        @api.route('/thing-2/')
        class Thing2Resource(Resource):
            @api.marshal_with(thing)
            def get(self):
                return {'owner': Child2()}

        data = client.get_json('/thing-1/',
                               headers={'X-Fields': 'owner{name}'})
        assert data == {'owner': {'name': 'child1'}}

        data = client.get_json('/thing-1/',
                               headers={'X-Fields': 'owner{extra1}'})
        assert data == {'owner': {'extra1': 'extra1'}}

        data = client.get_json('/thing-2/',
                               headers={'X-Fields': 'owner{name}'})
        assert data == {'owner': {'name': 'child2'}}
예제 #2
0
    def test_marshal_handle_inheritance(self, app):
        api = Api(app)

        person = api.model('Person', {
            'name': fields.String,
            'age': fields.Integer,
        })

        child = api.inherit('Child', person, {
            'extra': fields.String,
        })

        data = {'name': 'John Doe', 'age': 42, 'extra': 'extra'}

        values = (
            ('name', {
                'name': 'John Doe'
            }),
            ('name,extra', {
                'name': 'John Doe',
                'extra': 'extra'
            }),
            ('extra', {
                'extra': 'extra'
            }),
        )

        for value, expected in values:
            result = marshal(data, child, mask=value)
            assert result == expected
예제 #3
0
    def test_list_fields_with_nested_inherited(self, app):
        api = Api(app)

        person = api.model('Person', {
            'name': fields.String,
            'age': fields.Integer
        })
        child = api.inherit('Child', person, {
            'attr': fields.String
        })

        family = api.model('Family', {
            'children': fields.List(fields.Nested(child))
        })

        result = mask.apply(family.resolved, 'children{name,attr}')

        data = {'children': [
            {'name': 'John', 'age': 5, 'attr': 'value-john'},
            {'name': 'Jane', 'age': 42, 'attr': 'value-jane'},
        ]}
        expected = {'children': [
            {'name': 'John', 'attr': 'value-john'},
            {'name': 'Jane', 'attr': 'value-jane'},
        ]}

        assert_data(marshal(data, result), expected)
        # Should leave th original mask untouched
        assert_data(marshal(data, family), data)
예제 #4
0
    def test_marshal_with_honour_complex_field_mask_header(self, app, client):
        api = Api(app)

        person = api.model('Person', person_fields)
        child = api.inherit('Child', person, {
            'attr': fields.String
        })

        family = api.model('Family', {
            'father': fields.Nested(person),
            'mother': fields.Nested(person),
            'children': fields.List(fields.Nested(child)),
            'free': fields.List(fields.Raw),
        })

        house = api.model('House', {
            'family': fields.Nested(family, attribute='people')
        })

        @api.route('/test/')
        class TestResource(Resource):
            @api.marshal_with(house)
            def get(self):
                return {'people': {
                    'father': {'name': 'John', 'age': 42},
                    'mother': {'name': 'Jane', 'age': 42},
                    'children': [
                        {'name': 'Jack', 'age': 5, 'attr': 'value-1'},
                        {'name': 'Julie', 'age': 7, 'attr': 'value-2'},
                    ],
                    'free': [
                        {'key-1': '1-1', 'key-2': '1-2'},
                        {'key-1': '2-1', 'key-2': '2-2'},
                    ]
                }}

        data = client.get_json('/test/', headers={
            'X-Fields': 'family{father{name},mother{age},children{name,attr},free{key-2}}'
        })
        assert data == {'family': {
            'father': {'name': 'John'},
            'mother': {'age': 42},
            'children': [{'name': 'Jack', 'attr': 'value-1'}, {'name': 'Julie', 'attr': 'value-2'}],
            'free': [{'key-2': '1-2'}, {'key-2': '2-2'}]
        }}
예제 #5
0
poem_model = api.model(
    'Poem', {
        'paragraphs':
        fields.List(fields.String,
                    example=['First paragraph.', 'Second paragraph.'],
                    required=True),
        'date_generated':
        fields.DateTime(dt_format='iso8601',
                        example='2020-12-22T11:26:05.594814+00:00',
                        required=True)
    })

poem_with_hash_model = api.inherit(
    'Poem With Hash', poem_model, {
        'hash':
        fields.String(example='1fe6ec3ce370e8d710a061afde3eee1d',
                      required=True)
    })

time_range = reqparse.RequestParser()

time_range.add_argument('from',
                        default='2020-01-01',
                        help='An ISO 8601 formatted date.',
                        required=True,
                        type=datetime.fromisoformat,
                        location='args')

time_range.add_argument('until',
                        default='2020-02-01',
                        help='An ISO 8601 formatted date.',
예제 #6
0
    {
        "id": fields.Integer(
            attribute="_id", description="Die ID eines Business Objects"
        ),
        "erstellungszeitpunkt": fields.String(
            attribute="_erstellungszeitpunkt", description="Timestamp des BO"
        ),
    },
)

nachricht = api.inherit(
    "Nachricht",
    bo,
    {
        "inhalt": fields.String(attribute="_inhalt", description="Nachrichteninhalt"),
        "absender_id": fields.Integer(attribute="_absender_id", description="Absender"),
        "konversation_id": fields.Integer(
            attribute="_konversation_id", description="Konversationszugehörigkeit"
        ),
    },
)

gruppenteilnahme = api.inherit(
    "GruppenTeilnahme",
    bo,
    {
        "person_id": fields.Integer(
            attribute="_person_id", description="Useridentifikation"
        ),
        "gruppen_id": fields.Integer(
            attribute="_gruppen_id", description="Gruppenidentifikation"
예제 #7
0
app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app)
api = Api(app, version='1.0', title='ML API Example', validate=True)

ns = api.namespace('iris', description='IRIS model')

iris_row = api.model(
    'IrisRow', {
        'sepal_length': fields.Float(required=True),
        'sepal_width': fields.Float(required=True),
        'petal_length': fields.Float(required=True),
        'petal_width': fields.Float(required=True)
    })

iris_prediction = api.inherit(
    'IrisPrediction', iris_row,
    {'prediction': fields.List(fields.Float, min_items=3, max_items=3)})


@ns.route('/')
class IrisClassification(Resource):
    @ns.doc('obtain_prediction')
    @ns.expect(iris_row)
    @ns.marshal_with(iris_prediction, code=200)
    def post(self):
        payload = api.payload
        values_tuple = tuple(payload.values())
        prediction = [
            round(p, 5) for p in model.predict_proba([values_tuple])[0]
        ]
        payload.update({'prediction': prediction})
예제 #8
0
"""Namespaces"""
electivApp = api.namespace('electivApp', description='Functions of electivApp')

"""Hier wird definiert, wie die Businessobjects beim Marshelling definiert 
werden sollen"""
bo = api.model('BusinessObject', {
    'id': fields.Integer(attribute='_id', description='ID des BOs'),
})

automat = api.model('Automat',{
    'aktueller_zustand': fields.String(attribute='_aktueller_zustand', description='ID des aktuellen Zustands des Automaten')
})

nbo = api.inherit('NamedBusinessObject', bo, {
    'name': fields.String(attribute='_name', description='Name des BOs'),
})

person = api.inherit('Person', nbo, {
    'email': fields.String(attribute='_email', description='Email der Person'),
    'google_user_id': fields.String(attribute='_google_user_id', description='Google user ID der Person'),
    'rolle': fields.String(attribute='_rolle', description='Rolle der Person')
})

student = api.inherit('Student', person, {
    'mat_nr': fields.Integer(attribute='_mat_nr', description='Die Matrikelnummer des Studenten'),
    'kuerzel': fields.String(attribute='_kuerzel', description='Kuerzel des Studenten')
})

projekt = api.inherit('Projekt', nbo, automat, {
    'max_teilnehmer': fields.Integer(attribute='_max_teilnehmer', description='Maximale Anzahl an teilnehmern'),
예제 #9
0
        fields.String(required=True,
                      description='The last name of the Customer'),
        'email':
        fields.String(required=True, description='The email of the Customer'),
        'address':
        fields.String(required=True,
                      description='The address of the Customer'),
        'active':
        fields.Boolean(required=True,
                       description='Is the Customer avaialble for purchase?')
    })

customer_model = api.inherit(
    'CustomerModel', create_model, {
        'id':
        fields.String(
            readOnly=True,
            description='The unique id assigned internally by service'),
    })

# query string arguments
customer_args = reqparse.RequestParser()
customer_args.add_argument('first_name',
                           type=str,
                           required=False,
                           help='List Customers by first name')
customer_args.add_argument('last_name',
                           type=str,
                           required=False,
                           help='List Customers by last name')
customer_args.add_argument('email',
예제 #10
0
                        description='Erstellungszeitpunkt des Objekts')
    })

nbo = api.model(
    'NamedBusinessObject', {
        'name':
        fields.String(attribute='_name',
                      description='Der Name eines Named Business Object'),
    })

user = api.inherit(
    'User', bo, {
        'name':
        fields.String(attribute='_name', description='Name eines Benutzers'),
        'email':
        fields.String(attribute='_email',
                      description='E-Mail-Adresse eines Benutzers'),
        'user_id':
        fields.String(attribute='_user_id',
                      description='Google User ID eines Benutzers')
    })

module = api.inherit('Module', bo, nbo, {
    'edv_nr':
    fields.String(attribute='_edv_nr', description='EDV_Nr des Moduls')
})

participation = api.inherit(
    'Participation', bo, {
        'project':
        fields.Integer(attribute='_project',
예제 #11
0
von Namespace könnte etwa sein, unterschiedliche API-Version voneinander zu trennen, um etwa 
Abwärtskompatibilität (vgl. Lehrveranstaltungen zu Software Engineering) zu gewährleisten. Dies ließe
sich z.B. umsetzen durch /bank/v1, /bank/v2 usw."""
banking = api.namespace('bank', description='Funktionen des BankBeispiels')

"""Nachfolgend werden analog zu unseren BusinessObject-Klassen transferierbare Strukturen angelegt.

BusinessObject dient als Basisklasse, auf der die weiteren Strukturen Customer, Account und Transaction aufsetzen."""
bo = api.model('BusinessObject', {
    'id': fields.Integer(attribute='_id', description='Der Unique Identifier eines Business Object'),
})

"""Users, Customers, Accounts & Transactions sind BusinessObjects..."""
user = api.inherit('User', bo, {
    'name': fields.String(attribute='_name', description='Name eines Benutzers'),
    'email': fields.String(attribute='_email', description='E-Mail-Adresse eines Benutzers'),
    'user_id': fields.String(attribute='_user_id', description='Google User ID eines Benutzers')
})

customer = api.inherit('Customer', bo, {
    'first_name': fields.String(attribute='_first_name', description='Vorname eines Kunden'),
    'last_name': fields.String(attribute='_last_name', description='Nachname eines Kunden')
})

account = api.inherit('Account', bo, {
    'owner': fields.Integer(attribute='_owner', description='Unique Id des Kontoinhabers')
})

transaction = api.inherit('Transaction', bo, {
    'source_account': fields.Integer(attribute='_source_account', description='Unique Id des Quellkontos'),
    'target_account': fields.Integer(attribute='_target_account', description='Unique Id des Zielkontos'),
예제 #12
0
 zu den methoden (api.model/api.inherit) findet man mehr auf der Flask Seite unter Response marshalling
 https://flask-restplus.readthedocs.io/en/stable/marshalling.html?highlight=nested#nested-field """

bo = api.model('BusinessObject', {
    'name': fields.String(attribute='_name', description='Name eines Objekts'),
    'id': fields.Integer(attribute='_id', description='Der Unique Identifier eines Business Object'),
    'creation_date' : fields.Integer(attribute='_creation_date',
                                     description='Erstellungsdatum des BOs, wird durch Unix Time Stamp ermittlet')
})

"""mit attribute='' wird gerenamed"""
group = api.inherit('Group', bo, {
    'owner_id': fields.Integer(attribute='_owner', description='Unique Id des Kontoinhabers'),
    'members': fields.Array(attribute='_members', description='Eine liste aller Gruppenmitglieder'),
    'articles' : fields.Array(attribute='_articles',
                                     description='Liste aller Artikeln'),
    'shoppingslists' : fields.Array(attribute='_shoppinglist',
                                     description='Liste aller listen der Gruppe'),
    'standardarticles' : fields.Array(attribute='_standardarticles',
                                     description='Liste aller standardartikeln der Gruppe'),
})

person = api.inherit('Person', bo, {
    'email': fields.String(attribute='_email', description='E-Mail-Adresse eines Benutzers'),
    'groups': fields.Array(attribute='_groups',
                           description='Eine liste aller Gruppen an der die Person beteiligt ist '),
})

"""Datentyp von Gruppe?"""
shoppingList = api.inherit('ShoppingList', bo, {
    'group': fields.String(attribute='_group', description='zu welcher groupe diese Liste gehört'),
    'list_entries': fields.Array(attribute='_list_entries',
예제 #13
0
)

wm_text_model = api.model(
    'WMText',
    {'text': fields.String(example='Rainfall causes floods.',
                           description='Text to process')})

jsonld_model = api.model(
    'jsonld',
    {'jsonld': fields.String(example='{}', description='JSON-LD reader output')})

eidos_text_model = api.inherit('EidosText', wm_text_model, {
    'webservice': fields.String(description='URL for Eidos webservice'),
    'grounding_ns': fields.List(
        fields.String, example=['WM'], required=False,
        description='A list of name spaces for which INDRA should represent groundings'),
    'extract_filter': fields.List(
        fields.String, example=['influence'], required=False,
        description='A list of relation types to extract'),
    'grounding_mode': fields.String(example='flat', required=False)
})

eidos_jsonld_model = api.inherit('EidosJson', jsonld_model, {
    'grounding_ns': fields.List(
        fields.String, example=['WM'], required=False,
        description='A list of name spaces for which INDRA should '
                    'represent groundings'),
    'extract_filter': fields.List(
        fields.String, example=['influence'], required=False,
        description='A list of relation types to extract'),
    'grounding_mode': fields.String(example='flat', required=False,
                                    description='flat or compositional')
    'sex': fields.Integer(required=True),
    'cp': fields.Integer(required=True),
    'trestbps': fields.Integer(required=True),
    'chol': fields.Integer(required=True),
    'fbs': fields.Integer(required=True),
    'restecg': fields.Integer(required=True),
    'thalach': fields.Integer(required=True),
    'exang': fields.Integer(required=True),
    'oldpeak': fields.Integer(required=True),
    'slope': fields.Integer(required=True),
    'ca': fields.Integer(required=True),
    'thal': fields.Integer(required=True)
})

heart_prediction = api.inherit('HeartPrediction', heart_row, {
    'prediction': fields.List(fields.Float, min_items=2, max_items=2),
    'prediction_class': fields.Integer
})

@ns.route('/')
class HeartClassification(Resource):
    @ns.doc('obtain_prediction')
    @ns.expect(heart_row)
    @ns.marshal_with(heart_prediction, code=200)
    def post(self):
        payload = api.payload
        values_tuple = tuple(payload.values())
        prediction = [round(p, 5) for p in model.predict_proba([values_tuple])[0]]
        predicted_class = np.argmax(prediction)
        payload.update({'prediction': prediction})
        payload.update({'prediction_class': predicted_class})
        return payload
예제 #15
0
     'corpus_id': fields.String(example='corpus1', required=False)
     }
)

wm_text_model = api.model(
    'WMText',
    {'text': fields.String(example='Rainfall causes floods.')})

jsonld_model = api.model(
    'jsonld',
    {'jsonld': fields.String(example='{}')})

eidos_text_model = api.inherit('EidosText', wm_text_model, {
    'webservice': fields.String,
    'grounding_ns': fields.List(fields.String(example=['WM']), required=False),
    'extract_filter': fields.List(fields.String(example=['Influence']),
                                  required=False),
    'grounding_mode': fields.String(example='flat', required=False)
})

eidos_jsonld_model = api.inherit('EidosJson', jsonld_model, {
    'grounding_ns': fields.List(fields.String(example=['WM']), required=False),
    'extract_filter': fields.List(fields.String(example=['Influence']),
                                  required=False),
    'grounding_mode': fields.String(example='flat', required=False)    
})

sofia_json_model = api.model(
    'json',
    {'json': fields.String(example='{}'),
     'extract_filter': fields.List(fields.String(example=['Influence']),
예제 #16
0
app = Flask(__name__)

CORS(app, resources=r"/shopping/*")

api = Api(app, version='1.0', title='ShoppingList API',
          description='Das ist unserer API für die Shoppinglist.')

shopping = api.namespace('shopping', description='Funktionen der Shoppinglist')

bo = api.model('BusinessObject', {
    'id': fields.Integer(attribute='_id', description='Der Unique Identifier eines Business Object'),
})

namedBO = api.inherit('namedBO', bo, {
    'name': fields.String(attribute='_name', description='Name des namedBO'),
    'erstellungs_zeitpunkt': fields.String(attribute='_erstellungs_zeitpunkt', description='Erstellungszeitpunkt'),
})

artikel = api.inherit('Artikel', namedBO, {
    'einheit': fields.String(attribute='_einheit', description='Name eines Artikels'),
    'standardartikel': fields.Boolean(attribute='_standardartikel', description='Standardartikel'),
    'benutzer_id': fields.Integer(attribute='_benutzer_id', description='BenutzerID'),
})

einzelhaendler = api.inherit('Einzelhandler', namedBO, bo)

benutzer = api.inherit('Benutzer', namedBO, {
    'email': fields.String(attribute='_email', description='Email des Benutzers'),
    'google_id': fields.String(attribute='_google_id', description='Google ID des Benutzers')
})
예제 #17
0
            attribute='_id',
            description='Der Unique Identifier eines Business Object'),
        'create_time':
        fields.Date(attribute='_create_time',
                    description='Erstellungszeitpunkt eines Business Objects')
    })
"""Participation, Validation und NamedBusinessObject sind BusinessObjects..."""

participation = api.inherit(
    'Participation', bo, {
        'module_id':
        fields.Integer(attribute='_module_id',
                       description='Die ID des zugehörigen Moduls'),
        'project_id':
        fields.Integer(attribute='_project_id',
                       description='Die ID des zugehörigen Projektes'),
        'student_id':
        fields.Integer(attribute='_student_id',
                       description='Die ID des zugehörigen Studenten'),
        'validation_id':
        fields.Integer(attribute='_validation_id',
                       description='Die ID der zugehörigen Bewertung')
    })

validation = api.inherit(
    'Validation', bo, {
        'grade':
        fields.String(attribute='_grade',
                      description='Bewertung eines Projektes')
    })
예제 #18
0
        fields.DateTime(attribute='_creation_date',
                        description='Erstellungsdatum des BOs, wird '
                        'durch Unix Time Stamp ermittlet',
                        dt_format="iso8601"),
        'lastUpdated':
        fields.DateTime(attribute='_last_updated',
                        description='Änderungsdatum des BOs, wird durch'
                        'Unix Time Stamp ermittlet',
                        dt_format="iso8601")
    })

user = api.inherit(
    'User', bo, {
        'email':
        fields.String(attribute='_email',
                      description='E-Mail-Adresse eines Benutzers'),
        'googleId':
        fields.String(attribute='_google_id',
                      description='google id eines Benutzers'),
    })

group = api.inherit(
    'Group', bo, {
        'owner':
        fields.Integer(attribute='_owner',
                       description='Unique Id des Gruppeninhabers'),
    })

shopping_list = api.inherit(
    'ShoppingList', bo, {
        'groupId':
예제 #19
0
})

nbo = api.model('NamedBusinessObject', { 
    'name': fields.String(attribute='_name',
                                description='Name eines BusinessObjects bzw. NamedBusinessObjects')
})  

automat = api.model('Automat', {
    'current_state': fields.String(attribute='_current_state',
                                description='Aktueller Zustand')
})

"""Participation, Grading, Module, Project, ProjectType, Semester, Person & Student sind BusinessObjects"""

participation = api.inherit('Participation', bo, {
    "student_id": fields.Integer(attribute='_student_id'),
    'project_id': fields.Integer(attribute='_project_id')
})

grading = api.inherit('Grading', bo, {
    'grade': fields.Float(attribute='_grade', 
                                description='Note zur Bewertung einer Projektteilnahme'),
    'participation_id': fields.Integer(attribute='participation_id')
})

module = api.inherit('Module', bo, nbo, {
    'edv_number': fields.String(attribute='_edv_number',
                                description='EDV-Nummer eines Moduls')
})

project = api.inherit('Project', bo, nbo, automat, {
    'capacity': fields.Integer(attribute='_capacity',
예제 #20
0
"""
Transferable structure: 
"""
bo = api.model(
    'BusinessObject', {
        'id': fields.Integer(attribute='_id', description="unique bo id"),
    })
"""
Business Objects: Group, ListEntry, user, retailer, report, article, shoppinglist and favourite articles 
"""
group = api.inherit(
    'Group', bo, {
        'name':
        fields.String(attribute='name', description="A groups name"),
        'description':
        fields.String(attribute='description',
                      description="A groups description"),
        'creationdate':
        fields.DateTime(attribute='creationdate',
                        description="The creationdate of group")
    })

user = api.inherit(
    'User', bo, {
        'name':
        fields.String(attribute='_name', description="An users name"),
        'email':
        fields.String(attribute='_email', description="An users email"),
        'firebase_id':
        fields.String(attribute='_firebase_id',
                      description="An users firebaseid"),
예제 #21
0
"""Namespaces"""
volleyTrain = api.namespace('volleyTrain',
                            description='Functions of volleyTrain')
"""Hier wird definiert, wie die Businessobjects beim Marshelling definiert 
werden sollen"""
bo = api.model(
    'BusinessObject', {
        'id':
        fields.Integer(attribute='_id', description='ID des BOs'),
        'creation_date':
        fields.DateTime(attribute='_creation_date',
                        description='Erstellungszeitpunkt')
    })

nbo = api.inherit(
    'NamedBusinessObject', bo, {
        'name': fields.String(attribute='_name', description='Name des BOs'),
    })

user = api.inherit(
    'user', nbo, {
        'surname':
        fields.String(attribute='_surname', description='Surname of user'),
        'email':
        fields.String(attribute='_email', description='Email der Person'),
        'googleUserId':
        fields.String(attribute='_googleUserId',
                      description='Google user ID der Person'),
    })

player = api.inherit(
    'nbo', nbo, {
예제 #22
0
파일: api.py 프로젝트: steppi/indra
        res = {'statements': stmts}
    else:
        res = {'statements': []}
    return res


# Create Resources in Preassembly Namespace

# Manually add preassembly resources not based on assembly corpus functions
pipeline_model = api.inherit(
    'Pipeline', stmts_model, {
        'pipeline':
        fields.List(fields.Nested(dict_model),
                    example=[{
                        'function': 'filter_grounded_only'
                    }, {
                        'function': 'run_preassembly',
                        'kwargs': {
                            'return_toplevel': False
                        }
                    }])
    })


# There's an extra blank line between parameters here and in all the following
# docstrings for better visualization in Swagger
@preassembly_ns.expect(pipeline_model)
@preassembly_ns.route('/pipeline')
class RunPipeline(Resource):
    @api.doc(False)
    def options(self):
예제 #23
0
        'is_site_wide': fields.Boolean(
            required=False, description='Is the promotion site wide?'
        ),
        'products': fields.List(
            cls_or_instance=fields.Integer,
            required=False,
            description='List of products associated with the promotion.',
        ),
    },
)

promotion_model = api.inherit(
    'PromotionModel',
    create_model,
    {
        'id': fields.Integer(
            readOnly=True, description='The unique id assigned internally by service'
        ),
    },
)

######################################################################
# Error Handlers
######################################################################
@api.errorhandler(DataValidationError)
def request_validation_error(error):
    """ Handles Value Errors from bad data """
    app.logger.error(str(error))
    return {
        'status_code': status.HTTP_400_BAD_REQUEST,
        'error': 'Bad Request',