def __init__(self):
routes = import_module(settings.APISTAR_ROUTE_CONF).routes
routes.append(Include('/static', static_urls))
routes.append(Include('/docs', docs_urls))
self.django_wsgi_app = get_wsgi_application()
self.apistar_wsgi_app = CORSApp(routes=routes,
settings=settings.APISTAR_SETTINGS)
def create_routes():
"""Create the routes for the application."""
return [
Route('/', 'GET', welcome),
Route('/authorities/', 'GET', get_authorities),
Route('/authorities/{authority}/gen/', 'GET', get_authority_generation),
Route('/authorities/{authority}/load/', 'GET', get_authority_load),
Route('/authorities/{authority}/lmp/', 'GET', get_authority_lmp),
Route('/authorities/{authority}/trade/', 'GET', get_authority_trade),
Include('/docs', docs_urls),
Include('/static', static_urls)
]
def login():
routes = [
Route('/', 'GET', welcome),
Include('/docs', docs_urls),
Include('/static', static_urls)
]
app = App(routes=routes)
if __name__ == '__main__':
app.main()
def routing(controller):
"""
获取当前Controller下所有route及其子Controller组成的Include
:param controller:
:return:
"""
if not hasattr(controller, "prefix"):
raise RuntimeError(f"{controller} is not routed! ")
routes = []
instance = controller()
for name in vars(controller).keys():
prop = getattr(controller, name)
if hasattr(prop, "routes"):
for route in prop.routes:
route.controller = instance
add_annotation(route.handler, find_ancestor(controller))
routes.append(route)
for child_controller in controller.__subclasses__():
child_include = routing(child_controller)
if child_include:
routes.append(child_include)
if routes:
return Include(controller.prefix, controller.name, routes)
def process_app_routes(app, prefix: typing.Union[str, tuple] = None):
"""
For a given dict of app data figure out if the app is nested
and if so convert the routes to an Include with the appropriate
URL prefix.
"""
routes = app.get("routes")
app_path = app.get("app_path")
inc_name = ""
url_prefix = "/"
# If the app has no routes or is not nested (no or empty app_path), do nothing.
if not routes or not app_path:
return app
if isinstance(prefix, tuple):
url_prefix = prefix[0]
if len(prefix) == 2:
inc_name = prefix[1] + ":"
elif prefix:
url_prefix = prefix
if url_prefix[-1] != "/":
url_prefix += "/"
inc_name += ":".join(app_path)
namespaced_routes = [
Route(
r.url,
r.method,
r.handler,
name=inc_name + ":" + r.name,
documented=r.documented,
standalone=r.standalone,
) for r in routes
]
# Build an Include for the set of nested URLs with the matching prefix
# for the directory structure
# If a prefix param is present, pre-pend it as well
app["routes"] = [
Include(url_prefix + "/".join(app_path),
name=inc_name,
routes=namespaced_routes)
]
return app
def routes(self, admin="/admin") -> typing.List[Include]:
"""
Generate the list of routes for all resources and admin views.
:param admin: Admin path, disabled if None.
:return: List of routes.
"""
r = [
Include(opts.url, r.name, r.routes)
for r, opts in self.resources.items()
]
private_routes = []
if admin:
a = Admin(*[r for r, opts in self.resources.items() if opts.admin])
r.append(Include(admin, "admin", a.routes, documented=False))
private_routes += a.metadata_routes
if private_routes:
r.append(
Include("/_crud", "crud", private_routes, documented=False))
return r
def routes(cls) -> Include:
"""
Returns:
Les routes pour chaque action
"""
return Include(
url=f"/{cls.model.url_name}",
name=cls.model.url_name,
routes=[
Route("/add/{acte_id}", method="POST", handler=cls.add_item()),
Route("/{item_id}/", method="DELETE", handler=cls.delete_item()),
# Route("/{acte_id}/", method="GET", handler=cls.one()),
Route("/{item_id}/", method="PUT", handler=cls.update_item()),
# Route("/patient/{patient_id}/", method="GET", handler=cls.liste()),
],
)
def do_routes(cls) -> Include:
"""
Returns:
Include: Les routes pour chaque action
"""
bases_routes = [
Route("/", method="POST", handler=cls.add()),
Route("/{acte_id}/", method="GET", handler=cls.one()),
Route("/{acte_id}/", method="DELETE", handler=cls.delete()),
Route("/{acte_id}/", method="PUT", handler=cls.update()),
Route("/patient/{patient_id}/", method="GET", handler=cls.liste()),
]
routes = [*bases_routes, *cls.routes_supplementaires()]
return Include(url=f"/{cls.model.url_name}",
name=cls.model.url_name,
routes=routes)
def routing(service, parent_prefix):
"""
获取当前Service下所有route及其子Service组成的Include
:param service:
:param parent_prefix:
:return:
"""
if not hasattr(service, "prefix") or service.prefix == parent_prefix:
raise RuntimeError(f"{service} is not routed! ")
routes = []
for name in dir(service):
prop = getattr(service, name)
if hasattr(prop, "routes"):
for route in prop.routes:
route.service = service
routes.extend(prop.routes)
for child_service in service.children:
child_include = routing(child_service, service.prefix)
if child_include:
routes.append(child_include)
if routes:
return Include(service.prefix, service.name, routes)
from apistar import Include, Route
from apistar.handlers import static_urls
from core import views
routes = [
Route('/', 'GET', views.welcome),
Route('/me', 'POST', views.me, name='me'),
Route('/criar-produto', 'POST', views.criar_produto, name='criar_produto'),
Route('/listar-produtos', 'GET', views.listar_produtos, name='listar_produtos'),
Route('/valida-cpf', 'POST', views.valida_cpf, name='valida_cpf'),
Route('/criar-usuario', 'POST', views.criar_usuario, name='criar_usuario'),
Route('/listar-usuarios', 'GET', views.listar_usuarios, name='listar_usuarios'),
Include('/static', static_urls)
]
def subpath(var: schema.Integer):
return {'var': var}
app = App(routes=[
Route('/found/', 'GET', found),
Route('/path_params/{var}/', 'GET', path_params),
Route('/path_param/{var}/', 'GET', path_param),
Route('/int/{var}/', 'GET', path_param_with_int),
Route('/full_path/{var}', 'GET', path_param_with_full_path),
Route('/max_length/{var}/', 'GET', path_param_with_max_length),
Route('/number/{var}/', 'GET', path_param_with_number),
Route('/integer/{var}/', 'GET', path_param_with_integer),
Include('/subpath', [
Route('/{var}/', 'GET', subpath),
]),
])
client = TestClient(app)
def test_200():
response = client.get('/found/')
assert response.status_code == 200
assert response.json() == {'message': 'Found'}
def test_404():
response = client.get('/404/')
assert response.status_code == 404
class Env(environment.Environment):
properties = {
'DEBUG': typesystem.boolean(default=False),
'DATABASE_URL': typesystem.string()
}
env = Env()
transcription_routes = [
Route('/', 'GET', routes.get_unvalidated_transcription),
Route('/export', 'GET', routes.export_validated_transcriptions_as_csv),
Route('/', 'POST', routes.create_validated_transcription)
]
routes = [Include('/transcription', transcription_routes)]
# Configure database settings.
settings = {
"DATABASE": {
"URL": env['DATABASE_URL'],
"METADATA": Base.metadata
},
}
class App(WSGIApp):
def __call__(self, environ, start_response):
cors = CORS(super().__call__, headers='*', methods='*', origin='*')
return cors(environ, start_response)
from apistar import Include, Route
from apistar.handlers import docs_urls, static_urls, serve_static
from apps.details import detail_routes
from apps.files import file_routes
from apps.users import user_routes
from apps.login import login, logout
from apps.index import index
api_routes = [
Include('/details', detail_routes),
Include('/files', file_routes),
Include('/users', user_routes),
Route('/login', 'POST', login),
Route('/logout', 'GET', logout),
]
routes = [
Include('/api', api_routes),
Include('/docs', docs_urls),
Route('/dist/{path}', 'GET', serve_static),
Route('/', 'GET', index),
# Include('/static', static_urls)
]
for path in ('/details', '/login', '/fileList', '/admin'):
routes.append(Route(path, 'GET', index, name=path))
},
)
def download_response_filename_in_url():
return http.Response(b"...", headers={"Content-Type": "image/jpeg"})
routes = [
Include(
url="/parameters",
name="parameters",
routes=[
Route(url="/no-parameters/", method="GET", handler=no_parameter),
Route(url="/query-parameter/",
method="GET",
handler=query_parameter),
Route(url="/body-parameter/",
method="POST",
handler=body_parameter),
],
),
Include(
url="/responses",
name="responses",
routes=[
Route(url="/text-response/", method="GET", handler=text_response),
Route(url="/empty-response/", method="GET",
handler=empty_response),
Route(url="/error-response/", method="GET",
handler=error_response),
"iat": pendulum.now(),
"exp": pendulum.now() + pendulum.Duration(seconds=1000),
}
token = jwt.encode(payload)
if token is None:
raise exceptions.ConfigurationError("échec de l'encodage jwt")
return token
routes_users = Include(
url="/users",
name="users",
routes=[
Route(url="/login/", method="POST", handler=login, name="login"),
# Route(url="/", method="GET", handler=liste),
# Route(url="/{id}/", method="PUT", handler=update),
# # Route(url="/patients/", method="DELETE", handler=delete),
# Route(url="/{id}/", method="DELETE", handler=delete),
# Route(url="/{id}/", method="GET", handler=get),
],
)
"""
# MEDECIN = "medecin"
# SECRETAIRE = "secretaire"
# INTERNE = "interne"
# REMPLACANT = "remplacant"
# STATUT = (
# (MEDECIN, 'Médecin'),
# (SECRETAIRE, 'Secrétaire'),
# (INTERNE, "Interne"),
# (REMPLACANT, "Remplaçant"),
try:
payload = jwt.decode(token,
settings['JWT_SECRET'],
algorithms=['HS256'])
return Authenticated(payload['user_id'])
except jwt.exceptions.InvalidTokenError:
raise Unauthorized()
@annotate(permissions=[])
async def create_token(data: LoginData, session: Session, settings: Settings):
user = session.query(User).filter_by(email=data['username']).first()
if not user or not user.password == data['password']:
raise BadRequest({"message": "Email and password do not match"})
expires = (datetime.now() + timedelta(days=5)).timestamp()
token = jwt.encode({
'user_id': user.id,
'exp': int(expires)
},
settings['JWT_SECRET'],
algorithm='HS256')
return {
'token_type': 'Bearer',
'access_token': token.decode('utf-8'),
'expires_in': int(expires),
}
routes = Include('/tokens', [Route('/', 'POST', create_token)])
from apistar import Include, Route
from apistar.docs import docs_routes
from apistar.statics import static_routes
from project.views import welcome, student, students_Id
from project.views import list_tasks, add_task, delete_task, patch_task
task_routes = [
Route('/', 'GET', list_tasks),
Route('/', 'POST', add_task),
Route('/{task_id}/', 'DELETE', delete_task),
Route('/{task_id}/', 'PATCH', patch_task),
]
routes = [
Route('/', 'GET', welcome),
Include('/task', task_routes),
Include('/docs', docs_routes),
Include('/static', static_routes),
Route('/students/id/{iD}', 'GET', students_Id),
Route('/students', 'GET', student)
]
def _blueprint_to_include(self, blueprint: Blueprint):
temp_app = Flask('temp_app')
temp_app.register_blueprint(blueprint)
routes = self._extract_routes(temp_app)
url_prefix = blueprint.url_prefix
return Include(url='', name=blueprint.name, routes=routes)
from wsgicors import CORS
from apistar import App, Include
from settings import jwt_settings
from components.auth import Auth
from middlewares import EventHookAuth
from api import auth
from api import users
from api import status
from api import features
from api import services
components = [Auth(jwt_settings)]
event_hooks = [EventHookAuth()]
routes = [
Include("/", name="Status", routes=status.routes),
Include("/auth", name="Authentication", routes=auth.routes),
Include("/users", name="User", routes=users.routes),
Include("/features", name="Feature", routes=features.routes),
Include("/services", name="Service", routes=services.routes),
]
app = App(routes=routes, components=components, event_hooks=event_hooks)
app = CORS(app, headers="*", methods="*", origin="*", maxage="86400")
else:
raise exceptions.Forbidden(
f"Action non autorisée pour l'utilisateur {user.username}")
def update(new_data: PatientUpdateSchema,
patient_id: int) -> http.JSONResponse:
"""modify patients
Args:
new_data: Rien n'est requis.
id: patient id.
"""
to_update = get_or_404(db.Patient, patient_id)
to_update.set(**{k: v for k, v in new_data.items() if v})
return http.JSONResponse(to_update.dico, status_code=201)
routes_patients = Include(
url="/patients",
name="patients",
routes=[
Route(url="/", method="POST", handler=add),
Route(url="/", method="GET", handler=liste),
Route(url="/{patient_id}/", method="PUT", handler=update),
Route(url="/{patient_id}/", method="DELETE", handler=delete),
Route(url="/{patient_id}/", method="GET", handler=one),
],
)
#
from apistar import Include
from idunn import settings
from idunn.utils.index_names import IndexNamesSettingsComponent
from idunn.utils.es_wrapper import ElasticSearchComponent
from idunn.utils.logging import init_logging, LogErrorHook
from idunn.utils.cors import CORSHeaders
from idunn.utils.app import IdunnApp
from idunn.api.urls import get_api_urls
from apistar_prometheus import PrometheusComponent, PrometheusHooks
init_logging(settings)
routes = [
Include('/v1', name='v1', routes=get_api_urls(settings)),
]
components = [
settings,
ElasticSearchComponent(),
IndexNamesSettingsComponent(),
PrometheusComponent()
]
# WARNING: using Classes (and not instances) in hooks list causes a memory leak.
# See https://github.com/encode/apistar/issues/606 for more details
event_hooks = [LogErrorHook(), CORSHeaders(), PrometheusHooks()]
app = IdunnApp(routes=routes,
schema_url='/schema',
components=components,
from apistar import App, Include
from project.hooks import Cors, MustBeAuthenticated
from users.routes import routes as users_routes
from users.models import UserComponent
routes = [
Include('', name='users', routes=users_routes),
]
event_hooks = [Cors, MustBeAuthenticated]
components = [UserComponent()]
app = App(routes=routes, event_hooks=event_hooks, components=components)
if __name__ == '__main__':
app.serve('0.0.0.0', 5000, debug=True)
def subpath(var: typesystem.Integer):
return {'var': var}
routes = [
Route('/found/', 'GET', found),
Route('/path_params/{var}/', 'GET', path_params),
Route('/path_param/{var}/', 'GET', path_param),
Route('/int/{var}/', 'GET', path_param_with_int),
Route('/full_path/{var}', 'GET', path_param_with_full_path),
Route('/max_length/{var}/', 'GET', path_param_with_max_length),
Route('/number/{var}/', 'GET', path_param_with_number),
Route('/integer/{var}/', 'GET', path_param_with_integer),
Route('/string/{var}/', 'GET', path_param_with_string),
Include('/subpath', [
Route('/{var}/', 'GET', subpath),
],
namespace='included'),
Route('/x', 'GET', lambda: 1, name='x'),
Include('/another_subpath', [Route('/x', 'GET', lambda: 1, name='x2')]),
]
wsgi_app = WSGIApp(routes=routes)
async_app = ASyncIOApp(routes=routes)
wsgi_client = TestClient(wsgi_app)
async_client = TestClient(async_app)
@pytest.mark.parametrize('client', [wsgi_client, async_client])
def test_200(client):
response = client.get('/found/')
assert response.status_code == 200
from apistar.frameworks.asyncio import ASyncIOApp as App
from apistar.handlers import docs_urls, static_urls
from apistar.backends import sqlalchemy_backend
from project.models import Base
from project.routes import user_routes
def welcome(name=None):
if name is None:
return {'message': 'Welcome to API Star!'}
return {'message': 'Welcome to API Star, %s!' % name}
routes = [
Route('/', 'GET', welcome),
Include('/docs', docs_urls),
Include('/static', static_urls),
Include('/users', user_routes)
]
settings = {
"DATABASE": {
"URL": "mysql+pymysql://root:qw010203@localhost/apistar",
"METADATA": Base.metadata
}
}
app = App(
routes=routes,
settings=settings,
@annotate(renderers=[HTMLRenderer()])
def hello(username: str):
return render_template('index.html', username=username)
def welcome(name=None):
if name is None:
return {'message': 'Welcome to API Star!'}
return {'message': 'Welcome to API Star, %s!' % name}
routes = [
Route('/', 'GET', hello),
Include('/docs', docs_urls),
Include('/static', static_urls),
Include('/playgound', bs_api.playground.routes),
]
settings = {
'TEMPLATES': {
'ROOT_DIR': 'templates', # Include the 'templates' direcotry.
'PACKAGE_DIRS': ['apistar'], # Include the buildin apistar templates.
},
'AUTHENTICATION': [BasicAuthentication()]
}
app = App(
routes=routes,
commands=bs_api.playground.commands,
from apistar import Include
from apistar.handlers import docs_urls, static_urls
from fortunes.urls import fortune_routes
routes = [
Include('/fortunes', fortune_routes),
Include('/docs', docs_urls),
Include('/static', static_urls),
]
from apistar import Include, Route
from apistar.docs import docs_routes
from apistar.statics import static_routes
from project.views import attempts, welcome, add_teacher, delete_teacher, teacher_details, teachers_list
routes = [
Route('/', 'GET', welcome),
Route('/attempts/', 'GET', attempts),
Route('/teachers/', 'GET', teachers_list),
Route('/teachers/', 'POST', add_teacher),
Route('/teacher/{teacher_id}/', 'GET', teacher_details),
Route('/teacher/{teacher_id}/', 'DELETE', delete_teacher),
Include('/docs', docs_routes),
Include('/static', static_routes),
]
settings = {
'DATABASES': {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': 'db.sqlite3',
}
},
'INSTALLED_APPS': [
'core',
'django.contrib.auth',
'django.contrib.contenttypes',
],
'AUTHENTICATION': [BasicDjangoAuthentication()],
}
if os.environ.get('TEST'):
settings['DATABASES']['default']['NAME'] = 'test.db.sqlite3'
if os.environ.get('DEBUG'):
routes.append(Include('/docs', docs_urls))
app = App(
routes=routes,
settings=settings,
commands=django_orm.commands,
components=django_orm.components,
)
if __name__ == '__main__':
app.main()
from apistar.frameworks.wsgi import WSGIApp as App
from apistar.handlers import docs_urls, static_urls
from apistar.backends import sqlalchemy_backend
from db.models import Base
from api import routes
def welcome(name=None):
if name is None:
return {'message': 'Welcome to db Star!'}
return {'message': 'Welcome to db Star, %s!' % name}
routes = routes + \
[
Include('/docs', docs_urls),
Include('/static', static_urls)
]
# Configure database settings
settings = {
"DATABASE": {
"URL": "sqlite:///Test.db",
"METADATA": Base.metadata
}
}
app = App(routes=routes,
settings=settings,
commands=sqlalchemy_backend.commands,
components=sqlalchemy_backend.components)
from apistar import App, Include
import custom_routes
routes = [Include("/api", name="api", routes=custom_routes.routes),]
app = App(routes)
if __name__ == "__main__":
app.serve("127.0.0.1", 9090, debug=True)