Hi there,

when trying out the example in the README, I get a strange import error for the typing module:

Traceback (most recent call last):
  File "D:/projects/autogram/autogram/api/registrations.py", line 3, in <module>
    from flama.applications import Flama
  File "C:\Users\joscha.goetzer\.virtualenvs\autogram-PRYPx28t\lib\site-packages\flama\applications.py", line 12, in <module>
    from flama.injection import Injector
  File "C:\Users\joscha.goetzer\.virtualenvs\autogram-PRYPx28t\lib\site-packages\flama\injection.py", line 8, in <module>
    from flama.components.validation import VALIDATION_COMPONENTS
  File "C:\Users\joscha.goetzer\.virtualenvs\autogram-PRYPx28t\lib\site-packages\flama\components\validation.py", line 13, in <module>
    from flama.routing import Route
  File "C:\Users\joscha.goetzer\.virtualenvs\autogram-PRYPx28t\lib\site-packages\flama\routing.py", line 10, in <module>
    from starlette.types import ASGIApp, ASGIInstance, Receive, Scope, Send
ImportError: cannot import name 'ASGIInstance'

Am I missing something?

Copy-pasting the example from readme produces this:

INFO: ('127.0.0.1', 33118) - "GET / HTTP/1.1" 500
ERROR: Exception in ASGI application
Traceback (most recent call last):
  File "<venv>/lib/python3.7/site-packages/uvicorn/protocols/http/httptools_impl.py", line 372, in run_asgi
    result = await asgi(self.receive, self.send)
  File "<venv>/lib/python3.7/site-packages/starlette/middleware/errors.py", line 125, in asgi
    raise exc from None
  File "<venv>/lib/python3.7/site-packages/starlette/middleware/errors.py", line 103, in asgi
    await asgi(receive, _send)
  File "<venv>/lib/python3.7/site-packages/starlette/exceptions.py", line 74, in app
    raise exc from None
  File "<venv>/lib/python3.7/site-packages/starlette/exceptions.py", line 63, in app
    await instance(receive, sender)
  File "<venv>/lib/python3.7/site-packages/starlette_api/routing.py", line 168, in awaitable
    injected_func = await app.injector.inject(endpoint, state)
  File "<venv>/lib/python3.7/site-packages/starlette_api/injection.py", line 173, in inject
    state[output_name] = resolver(**kw)
  File "<venv>/lib/python3.7/site-packages/starlette_api/components/validation.py", line 79, in resolve
    query_params = validator().load(dict(query_params), unknown=marshmallow.EXCLUDE)
AttributeError: module 'marshmallow' has no attribute 'EXCLUDE'

UPD: I used starlette-api[full] for install

Do you have a way or have a way planned on how to document multiple responses from an endpoint?

I would like to be able to document, for example, error responses from an endpoint such as BadRequest or validation errors and have that openapi information show up in the schema served to the swagger/redoc ui. It would also be nice to allow the @output_validation decorator could "validate" these as well if possible.

For reference, another somewhat similar framework has the same open question: https://github.com/tiangolo/fastapi/issues/16

Thanks for any info!

Hey, folks! :]

It would be great if we had a basic example on how to run this, so it's easier to jump into and contribute as well. If I have the time, I can do it, but if someone had that already set up, it would be nice!

Thanks!

Hi there, I just try to plugin authentication from Starlette, but looks like this is not possible. From Starlette doc

from starlette.authentication import requires

@requires('authenticated')
async def foobar(request, schema: Schema):
    pass

This will raise error AttributeError: 'OpenAPIConverter' object has no attribute 'field2parameter' from flama/schemas.py Can't omit first parameter request cause that is required from the requires decorator for authentication. Any work around? Thanks

When using Mounts to nest routes any more than a single level deep, schema generation ignores all levels before the last and general routing completely blows up . This resolves those issues.

example:

app.mount('/api/', app=Router(routes=[                                                                                                                                                                                                     
    Mount('/v1/', app=Router(routes=[                                                              
        Mount('/check/', app=Router(routes=[                                                 
            Route('/', EligibilityEndpoint, app.router, methods=['GET']),       
            Route('/bulk/', BulkEligibilityEndpoint, app.router, methods=['POST']),          
        ])),                                                                                       
        Mount('/membership/', app=Router(routes=[                                                  
            Route('/purchase/', MembershipPurchaseEndpoint, app.router, methods=['POST']),        
        ])),                                                                                       
    ])),                                                                                           
]))

Sorry, but I can't fix one issue because there is an issue with the dependencies and I don't know why.

1. when I use poetry install for the installation of the dependencies, it tries to install marshmallow 3.0.0rc4, but in the pyproject.toml file, it's 2.19.0. But this is not the case in the poetry.lock file.

and because I don't know poetry I have to learn the project and try to fix the issue with the dependency. Which version of marshmallow do you want to use? 3.0.0rc4 or 2.19.0 ?

Thanks you

I have added this test in tests/test_endpoints You can check here:

https://github.com/PeRDy/starlette-api/compare/master...matrixise:test_resources_many

    def test_nested_api(self, app, client):
        class Resource(marshmallow.Schema):
            name = marshmallow.fields.String()

        @app.route('/resources', methods=['GET'])
        class ResourcesHTTPEndpoint(HTTPEndpoint):
            async def get(self) -> Resource(many=True):
                return [{'name': 'Name'}]
        response = client.get('/resources')
        assert response.status_code == 200

but I get this exception because you are waiting for a class and not an instance, but in the case of Resource(many=True) it's an instance.

Do you know why?

tests/test_endpoints.py:92: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/requests/sessions.py:546: in get
    return self.request('GET', url, **kwargs)
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/starlette/testclient.py:382: in request
    json=json,
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/requests/sessions.py:533: in request
    resp = self.send(prep, **send_kwargs)
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/requests/sessions.py:646: in send
    r = adapter.send(request, **kwargs)
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/starlette/testclient.py:211: in send
    raise exc from None
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/starlette/testclient.py:208: in send
    loop.run_until_complete(connection(receive, send))
/usr/lib64/python3.7/asyncio/base_events.py:584: in run_until_complete
    return future.result()
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/starlette/middleware/errors.py:125: in asgi
    raise exc from None
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/starlette/middleware/errors.py:103: in asgi
    await asgi(receive, _send)
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/starlette/exceptions.py:74: in app
    raise exc from None
../../../../.virtualenvs/tempenv-713715370977/lib/python3.7/site-packages/starlette/exceptions.py:63: in app
    await instance(receive, sender)
starlette_api/endpoints.py:37: in __call__
    response = await self.dispatch(request, state, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

self = <tests.test_endpoints.TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint object at 0x7f0193c775c0>, request = <starlette.requests.Request object at 0x7f0193c776a0>
state = {'app': <starlette_api.applications.Starlette object at 0x7f0193c52cf8>, 'exc': None, 'path_params': {}, 'receive': <function _ASGIAdapter.send.<locals>.receive at 0x7f0193ca7bf8>, ...}
kwargs = {}, handler_name = 'get'
handler = <bound method TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint.get of <tests.test_endpoints.TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint object at 0x7f0193c775c0>>
app = <starlette_api.applications.Starlette object at 0x7f0193c52cf8>
injected_func = functools.partial(<bound method TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint.get of <tests.test_endpoints.TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint object at 0x7f0193c775c0>>)
response = [{'name': 'Name'}], return_annotation = <Resource(many=True)>

    async def dispatch(self, request: Request, state: typing.Dict, **kwargs) -> Response:
        handler_name = "get" if request.method == "HEAD" else request.method.lower()
        handler = getattr(self, handler_name, self.method_not_allowed)
    
        app = state["app"]
        injected_func = await app.injector.inject(handler, state)
    
        if asyncio.iscoroutinefunction(handler):
            response = await injected_func()
        else:
            response = injected_func()
    
        return_annotation = inspect.signature(handler).return_annotation
>       if issubclass(return_annotation, marshmallow.Schema):
E       TypeError: issubclass() arg 1 must be a class

app        = <starlette_api.applications.Starlette object at 0x7f0193c52cf8>
handler    = <bound method TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint.get of <tests.test_endpoints.TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint object at 0x7f0193c775c0>>
handler_name = 'get'
injected_func = functools.partial(<bound method TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint.get of <tests.test_endpoints.TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint object at 0x7f0193c775c0>>)
kwargs     = {}
request    = <starlette.requests.Request object at 0x7f0193c776a0>
response   = [{'name': 'Name'}]
return_annotation = <Resource(many=True)>
self       = <tests.test_endpoints.TestCaseHTTPEndpoint.test_nested_api.<locals>.ResourcesHTTPEndpoint object at 0x7f0193c775c0>
state      = {'app': <starlette_api.applications.Starlette object at 0x7f0193c52cf8>, 'exc': None, 'path_params': {}, 'receive': <function _ASGIAdapter.send.<locals>.receive at 0x7f0193ca7bf8>, ...}

starlette_api/endpoints.py:54: TypeError

Thank you,

Hi,

Here is a very small example when I try to construct an API with starlette-api but I get an error, could you tell me where my error is?

Thank you

import pytest
from marshmallow import Schema
from marshmallow import fields
from starlette.testclient import TestClient
from starlette_api.applications import Starlette
from starlette_api.endpoints import HTTPEndpoint
from starlette_api.routing import Router

class RunnerSchema(Schema):
    id = fields.Integer()
    name = fields.String()
    token = fields.String()

class RunnerEndpoint(HTTPEndpoint):
    async def get(self) -> RunnerSchema():
        return {"id": 1, "name": "name", "token": "token"}

def create_app():
    app = Starlette(
        components=[],
        title="Foo",
        version="0.1",
        description="Foo",
        schema=False,
        docs=False,
        debug=False,
    )

    api = Router()
    api.add_route("/runners", RunnerEndpoint, methods=["GET"])
    app.mount("/api/v4", api)

    return app

@pytest.fixture(scope="function")
def app():
    return create_app()


@pytest.fixture(scope="function")
def client(app):
    return TestClient(app)

def test_get_runners(client):
    response = client.get("/api/v4/runners")

    assert response.status_code == 200
    assert response.json() == {"id": 1, "name": "name", "token": "token"}

Result of pytest

self = <test_app.RunnerEndpoint object at 0x7f5dcb6c5588>, receive = <function _ASGIAdapter.send.<locals>.receive at 0x7f5dcb16d8c8>
send = <function ExceptionMiddleware.__call__.<locals>.app.<locals>.sender at 0x7f5dcb6c7620>

    async def __call__(self, receive: Receive, send: Send):
        request = Request(self.scope, receive=receive)
        app = self.scope["app"]
        kwargs = self.scope.get("kwargs", {})
    
        route, route_scope = app.router.get_route_from_scope(self.scope)
    
        state = {
            "scope": self.scope,
            "receive": receive,
            "send": send,
            "exc": None,
            "app": app,
>           "path_params": route_scope["path_params"],
            "route": route,
            "request": request,
        }
E       TypeError: 'NoneType' object is not subscriptable

app        = <starlette_api.applications.Starlette object at 0x7f5dcb6ab860>
kwargs     = {}
receive    = <function _ASGIAdapter.send.<locals>.receive at 0x7f5dcb16d8c8>
request    = <starlette.requests.Request object at 0x7f5dcb702a90>
route      = <bound method Router.not_found of <starlette_api.routing.Router object at 0x7f5dcb6ab978>>
route_scope = None
self       = <test_app.RunnerEndpoint object at 0x7f5dcb6c5588>
send       = <function ExceptionMiddleware.__call__.<locals>.app.<locals>.sender at 0x7f5dcb6c7620>

Version of starlette

starlette==0.11.3
starlette-api==0.5.0

objective can have api from cli e.g. request.headers['api_key'] curl -X GET -i http://localhost:8000/api/http_api_key/instrument/ -H 'api_key: stifix' request.query_params curl -X PUT -i "http://localhost:8000/api/put/instrument/2?name=name0&strings=0" request.form() curl -X PUT -d "name=name1&strings=1" -i http://localhost:8000/api/put/instrument/2 request.json() curl -X PUT -d '{"name": "name2", "strings": 2}' -i http://localhost:8000/api/put_json/instrument/2

in starlette we can use request e.g.

def test(request):
    request.headers['api_key']
    request.query_params
    request.form()
    request.json()

since flama is base on starlette, what is equivalent of starlette request above ?

thanks

The branding/logo of this project is great and "Flama" is a nicer name than its FastAPI competitor. However, the "with this flamethrower" tagline is overly narrow. Why is an API like a flamethrower? Just ends up sounding weird.

I suggest you just make the tagline "Fire up your API". Simple.

At the moment, the model serialisation builds a binary which contains:

• lib: ModelFormat
• model: typing.Any

Whilst this is OK, and it's allowed us keep making progress, we might highly benefit from having a much richer structure. Our previous discussion seems to point at something like:

{
	"data": {
		"binary": b"...",
	},
	"meta": {
		"id": ...,
		"timestamp": ...,
		"framework": {
			"lib": "...",
			"version": "...",
		},
		"model": {
				"class": "...",
				"info": {**info},
				"params": {**hyperparams},
				"metrics": {**metrics},
		},
		"extra": {
			**free_info
		},
	},
}

This will change the current implementation in model.py. Essentially, it will have to extend the dataclass:

@dataclasses.dataclass(frozen=True)
class Model:
    """ML Model wrapper to provide mechanisms for serialization and deserialization using Flama format."""

    lib: ModelFormat
    model: typing.Any

to accomodate the previous JSON structure.

Helpful links:

• pytorch: https://stackoverflow.com/questions/42480111/how-do-i-print-the-model-summary-in-pytorch
• keras/tensorflow:

  model.output_shape # model summary representation
  model.summary() # model configuration
  model.get_config() # list all weight tensors in the model
  model.get_weights() # get weights and biases
  

Modify how Routes and Routers are initialized and how are handling the main application to allow declarative routing for all Routes types.

An example of the goal syntax:

class PuppyResource(BaseResource, metaclass=CRUDResource):
    name = "puppy"
    model = puppy_model
    schema = puppy_schema

routes = [
    Route("/", root_mock),
    ResourceRoute("/", PuppyResource),
    Mount("/foo", routes=[
        Route("/", foo_mock, methods=["GET"]),
        Route("/view", foo_view_mock, methods=["GET"])
    ])
]

app = Flama(routes=routes)