methods = ("create", "retrieve", "update", "delete", "list", "drop")
@classmethod
def list(
cls, session: Session, page: http.QueryParam, page_size: http.QueryParam, name: http.QueryParam
) -> typing.List[PuppyOutputType]:
return PageNumberResponse(page=page, page_size=page_size, content=cls._filter(session=session, name=name))
routes = [Include("/puppy", "puppy", PuppyResource.routes)]
sqlalchemy_component = SQLAlchemySessionComponent(url="sqlite://")
components = [sqlalchemy_component]
event_hooks = [SQLAlchemyTransactionHook()]
app = App(routes=routes, components=components, event_hooks=event_hooks)
async_app = ASyncApp(routes=routes, components=components, event_hooks=event_hooks)
class TestCaseSQLAlchemyCRUD:
@pytest.fixture(scope="function", params=[app, async_app])
def client(self, request):
database.Base.metadata.create_all(sqlalchemy_component.engine)
yield TestClient(request.param)
database.Base.metadata.drop_all(sqlalchemy_component.engine)
@pytest.fixture
def puppy(self):
return {"name": "canna"}
@pytest.fixture
from apistar import App, ASyncApp, TestClient
async_app = ASyncApp(routes=[])
async_test_client = TestClient(async_app)
app = App(routes=[])
test_client = TestClient(app)
def test_docs():
response = test_client.get("/docs/")
assert response.status_code == 200
def test_docs_async():
response = async_test_client.get("/docs/")
assert response.status_code == 200
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_star.settings")
from apistar import App, Route
from django_orm.views import *
# Ensure settings are read
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
def welcome(name=None):
if name is None:
return {'message': 'Welcome to API Star!'}
return {'message': 'Welcome to API Star, %s!' % name}
routes = [
Route('/', method='GET', handler=welcome),
Route('/users/', method='GET', handler=list_users),
Route('/users/', method='POST', handler=create_users),
Route('/products/', method='GET', handler=list_products),
Route('/products/', method='POST', handler=create_product),
]
app = App(routes=routes)
if __name__ == '__main__':
app.serve('127.0.0.1', 8000, use_debugger=True, use_reloader=True)
from apistar import App, Route
def welcome():
return {'message': 'Welcome to API Star!'}
app = App(routes=[Route('/', 'GET', welcome)])
from apistar import App
from routes import routes
from components import components
from event_hooks import event_hooks
app = App(routes=routes, components=components, event_hooks=event_hooks)
if __name__ == "__main__":
default = {"host": "127.0.0.1", "port": 5000, "debug": True}
app.serve(**default)
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)
def __init__(
self,
db_name,
db_filepath,
network_middleware,
federated_only,
treasure_map_tracker,
node_tracker,
node_bytes_caster,
work_order_tracker,
node_recorder,
stamp,
verifier,
suspicious_activity_tracker,
certificate_dir,
) -> None:
self.network_middleware = network_middleware
self.federated_only = federated_only
self._treasure_map_tracker = treasure_map_tracker
self._work_order_tracker = work_order_tracker
self._node_tracker = node_tracker
self._node_bytes_caster = node_bytes_caster
self._node_recorder = node_recorder
self._stamp = stamp
self._verifier = verifier
self._suspicious_activity_tracker = suspicious_activity_tracker
self._certificate_dir = certificate_dir
self.datastore = None
routes = [
Route('/kFrag/{id_as_hex}', 'POST', self.set_policy),
Route('/kFrag/{id_as_hex}/reencrypt', 'POST',
self.reencrypt_via_rest),
Route('/public_information', 'GET', self.public_information),
Route('/node_metadata', 'GET', self.all_known_nodes),
Route('/node_metadata', 'POST', self.node_metadata_exchange),
Route('/consider_arrangement', 'POST', self.consider_arrangement),
Route('/treasure_map/{treasure_map_id}', 'GET',
self.provide_treasure_map),
Route('/status', 'GET', self.status),
Route('/treasure_map/{treasure_map_id}', 'POST',
self.receive_treasure_map),
]
self.rest_app = App(routes=routes)
self.db_name = db_name
self.db_filepath = db_filepath
from nucypher.keystore import keystore
from nucypher.keystore.db import Base
from sqlalchemy.engine import create_engine
self.log.info("Starting datastore {}".format(self.db_filepath))
engine = create_engine('sqlite:///{}'.format(self.db_filepath))
Base.metadata.create_all(engine)
self.datastore = keystore.KeyStore(engine)
self.db_engine = engine
from nucypher.characters.lawful import Alice, Ursula
self._alice_class = Alice
self._node_class = Ursula
with open(os.path.join(TEMPLATES_DIR, "basic_status.j2"), "r") as f:
_status_template_content = f.read()
self._status_template = Template(_status_template_content)
def reboot(ip):
"""
ip: 要重启机器的ip
# https://github.com/onyxfish/relay/issues/11
# https://stackoverflow.com/questions/3586106/perform-commands-over-ssh-with-python
# https://codereview.stackexchange.com/questions/171179/python-script-to-execute-a-command-using-paramiko-ssh
"""
cmd_str = "mkdir -p /tmp/michaeltest"
ssh = paramiko.SSHClient()
ssh.load_system_host_keys()
ssh.connect(ip, username='******', password="******")
ssh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command(cmd_str)
print(type(ssh_stdin))
print(ssh_stdout.read().decode())
print(ssh_stderr.read().decode())
status = 'success' if not ssh_stderr.read().decode() else 'failure'
ssh.close()
return {'ip': ip, 'cmd': cmd_str, 'status': status}
routes = [
Route('/', method='Get', handler=welcome),
Route('/ip', method='Get', handler=get_ip),
Route('/machine/{ip}', method='Get', handler=reboot)
]
app = App(routes=routes)
if __name__ == '__main__':
app.serve('0.0.0.0', 5000, debug=True)
error = {"error": MOVIE_NOT_FOUND}
return JSONResponse(error, status_code=404)
del movies[movie_id]
return JSONResponse({}, status_code=204)
def get_rating_greater_than(rating: float) -> JSONResponse:
rating = float(rating)
return sorted(
[movie for movie in movies.values() if movie.get("rating") >= rating],
key=lambda x: x.get("rating"),
reverse=True,
)
routes = [
Route("/", method="GET", handler=list_movies),
Route("/", method="POST", handler=create_movie),
Route("/{movie_id}/", method="GET", handler=get_movie),
Route("/{movie_id}/", method="PUT", handler=update_movie),
Route("/{movie_id}/", method="DELETE", handler=delete_movie),
Route("/genre/{genre}/", method="GET", handler=list_movies_by_genre),
Route("/rating/{rating}", method="GET", handler=get_rating_greater_than),
]
app = App(routes=routes)
if __name__ == "__main__":
app.serve("127.0.0.1", 5000, debug=True)
def resource_body(computer: BodyData[Computer]):
return "%s costs R$ %.2f" % (computer.model, computer.price)
def resource_mixed(city: QueryData[City],
computer: BodyData[Computer]):
return ComputerCity(**city.dict(), **computer.dict())
#
# Start the app
#
app = App(
routes=[
Route('/resource_complete_undocumented', 'GET',
resource_complete_undocumented, documented=False),
Route('/resource_complete', 'GET', resource_complete),
Route('/resource_query', 'GET', resource_query, documented=False),
Route('/resource_body', 'POST', resource_body),
Route('/resource_mixed', 'POST', resource_mixed, documented=False),
],
components=[
*components
]
)
if __name__ == '__main__':
app.serve('127.0.0.1', 3000, debug=True)
def get_settings(settings: Settings):
return settings
def get_setting(ABC: Setting):
return {'ABC': ABC}
routes = [
Route('/settings/', 'GET', get_settings),
Route('/setting/', 'GET', get_setting),
]
settings = {'ABC': 123, 'XYZ': 456}
app = App(routes=routes, settings=settings)
client = TestClient(app)
def test_settings():
response = client.get('/settings/')
assert response.status_code == 200
assert response.json() == {'ABC': 123, 'XYZ': 456}
def test_setting():
response = client.get('/setting/')
assert response.status_code == 200
assert response.json() == {
'ABC': 123,
def template_handler(app: App, name: str = None) -> http.HTMLResponse:
return http.HTMLResponse(app.render_template('test.html', name=name))
def create_kitten(db: SQLAlchemy, name: http.QueryParam):
session = db.session_class()
add_kitten = Kitten(name=name)
session.add(add_kitten)
session.commit()
created_kitten = add_kitten.serialize()
session.close()
return created_kitten
app = App(routes=[
routing.Route('/kittens/create/', 'GET', create_kitten),
routing.Route('/kittens/', 'GET', list_kittens),
],
settings={
"DATABASE": {
"URL": environ.get('DB_URL', 'sqlite:///test.db'),
"METADATA": Base.metadata
}
},
commands=[create_sqlalchemy_tables])
client = test.TestClient(app)
runner = CommandLineRunner(app)
@pytest.fixture
def clear_db(scope="function"):
yield
db_backend = SQLAlchemy.build(app.settings)
db_backend.drop_tables()
def welcome(app: App, name=None):
return app.render_template('index.html', name=name)
{'message': f'Route with source {source} doesn\'t exist'},
status_code=404,
)
routes = [
Route('/api/routes', method='GET', handler=list_routes),
Route('/api/routes', method='POST', handler=create_route),
Route('/api/routes/{source}', method='GET', handler=get_route),
Route('/api/routes/{source}', method='PUT', handler=update_route),
Route('/api/routes/{source}', method='DELETE', handler=delete_route),
# Allow trailing slashes as well (GitHub style)
Route('/api/routes/', method='GET', handler=list_routes, name='list_routes_trailing_slash'),
Route('/api/routes/', method='POST', handler=create_route, name='create_route_trailing_slash'),
Route('/api/routes/{source}/', method='GET', handler=get_route, name='get_route_trailing_slash'),
Route('/api/routes/{source}/', method='PUT', handler=update_route, name='update_route_trailing_slash'),
Route('/api/routes/{source}/', method='DELETE', handler=delete_route, name='delete_route_trailing_slash'),
]
app = App(routes=routes)
if __name__ == '__main__':
from ceryx import settings
app.serve(
settings.API_BIND_HOST,
settings.API_BIND_PORT,
use_debugger=settings.DEBUG,
use_reloader=settings.DEBUG,
)
return http.Response({
'method': request.method,
'url': request.url,
'headers': dict(request.headers)
})
app = App(routes=[
Route('/method/', 'get', get_method),
Route('/method/', 'post', get_method),
Route('/scheme/', 'get', get_scheme),
Route('/host/', 'get', get_host),
Route('/port/', 'get', get_port),
Route('/root_path/', 'get', get_root_path),
Route('/path/', 'get', get_path),
Route('/query_string/', 'get', get_query_string),
Route('/query_params/', 'get', get_query_params),
Route('/page_query_param/', 'get', get_page_query_param),
Route('/url/', 'get', get_url),
Route('/body/', 'post', get_body),
Route('/headers/', 'get', get_headers),
Route('/accept_header/', 'get', get_accept_header),
Route('/request/', 'get', get_request),
])
client = TestClient(app)
def test_method():
response = client.get('http://example.com/method/')
assert response.json() == {'method': 'GET'}
author = curs.fetchall()[0][0]
if user_id == author:
return update_video_status(video_id, user_id)
else:
return "your user name is imvalidated"
def update_video_status(video_id, user_id):
now = datetime.now()
formatted_date = now.strftime("""%Y-%m-%d %H:%M:%S""")
curs = conn.cursor()
update_status = "UPDATE wp_uploaded_video SET status='delete', uploaded_time=%s WHERE video_id=%s"
curs.execute(update_status, (formatted_date, video_id))
conn.commit()
return webbrowser.open('http://192.168.10.37/my_video_list')
# headers = {'Location', 'http://192.168.10.37/my_video_list'}
routes = [
Route('/{video_id}', method='GET', handler=is_validated_user),
# Route('/{video_id}', method='GET', handler=update_video_status)
]
app = App(routes=routes)
if __name__ == "__main__":
app.serve('192.168.10.37', 5000, use_debugger=True)
from resource.todo import ROUTES as TODO_ROUTES
from apistar import App, Include
ROUTES = [
Include('/todos', name='users', routes=TODO_ROUTES),
]
APP = App(routes=ROUTES)
if __name__ == '__main__':
APP.serve('127.0.0.1', 5000, debug=True)
from apistar import App, Route
def welcome(name=None):
if name:
return {"msg": "Welcome to API Star, %s" % name}
else:
return {"msg": "Welcome to API Star!"}
routes = [Route("/", method="GET", handler=welcome)]
app = App(routes=routes)
if __name__ == "__main__":
app.serve("0.0.0.0", 5000, debug=True) # serve on 0.0.0.0 for docker use
return {
'var': var
}
def path_param_with_integer(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('/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),
])
client = TestClient(app)
def test_200():
response = client.get('/found/')
assert response.status_code == 200
assert response.json() == {
'message': 'Found'
}
def napp(request):
""" No Auth App; No Db_session"""
# event_hooks = []
return App(routes=routes, components=components)
def test_misconfigured_route():
def set_type(var: set): # pragma: nocover
pass
with pytest.raises(exceptions.ConfigurationError):
App(routes=[Route('/{var}/', 'GET', set_type)])
if car_id not in cars:
return JSONResponse(ERROR_CAR_NOT_FOUND, STATUS_NOT_FOUND)
car_obj = Car(car)
car_obj.id = car_id
cars[car_id].update(car_obj)
return JSONResponse(car_obj)
def delete_car(car_id: int) -> JSONResponse:
"""Delete stored car."""
if car_id not in cars:
return JSONResponse(ERROR_CAR_NOT_FOUND, STATUS_NOT_FOUND)
cars.pop(car_id)
return JSONResponse({}, STATUS_NO_CONTENT)
routes = [
Route("/", method="get", handler=get_cars),
Route("/", method="post", handler=create_car),
Route("/{car_id}", method="get", handler=get_car),
Route("/{car_id}", method="put", handler=update_car),
Route("/{car_id}", method="delete", handler=delete_car),
]
app = App(routes=routes)
if __name__ == "__main__":
SERVER_PORT = 5000
SERVER_IP = "127.0.0.1"
app.serve(SERVER_IP, SERVER_PORT, debug=True)
def get_arg(var: int):
return {'var': var}
def get_query_param(query: float):
return {'query': query}
def get_query_param_with_schema(query: schema.Number):
return {'query': query}
app = App(routes=[
Route('/found/', 'GET', found),
Route('/args/{var}/', 'GET', get_args),
Route('/arg/{var}/', 'GET', get_arg),
Route('/query_param/', 'GET', get_query_param),
Route('/query_param_with_schema/', 'GET', get_query_param_with_schema),
])
client = TestClient(app)
def test_404():
response = client.get('/404/')
assert response.status_code == 404
assert response.json() == {'message': 'Not found'}
def test_405():
response = client.post('/found/')
def app():
return App(routes=routes, event_hooks=event_hooks)
"EXAMPLE": 42,
})
class SettingsComponent(Component):
def resolve(self) -> Settings:
return SETTINGS
@actor
def print_x_and_settings(x, settings: Settings):
print(x)
print(settings)
def index() -> dict:
print_x_and_settings.send(42)
return {}
routes = [
Route("/", method="GET", handler=index),
]
components = [
SettingsComponent(),
]
app = App(routes=routes, components=components)
apistar_dramatiq.setup(components)
}
"""
image_binary_data = request.body.read()
face_location_information = _detect_faces(image_binary_data)
face_hashes = []
for face_location_bbox in face_location_information['face_locations']:
face_image = _extract_face(image_binary_data, face_location_bbox)
facial_landmarks = _detect_facial_landmarks(face_image)
face_hash = _hash_facial_landmarks(facial_landmarks)
face_information = {
'bbox': face_location_bbox,
'facial_landmarks': facial_landmarks,
'hash': face_hash,
'version': _hash_facial_landmarks.version
}
face_hashes.append(face_information)
return face_hashes
routes = [
Route('/', method='POST', handler=detect_and_analyze_faces),
]
app = App(routes=routes)
if __name__ == '__main__':
app.serve('127.0.0.1', 5000, debug=True)
from apistar import App, Route
def welcome(name=None):
if name is None:
return {"message": "Welcome to API Star!"}
return {"message": "Welcome to API Star, %s!" % name}
routes = [Route("/", method="GET", handler=welcome)]
app = App(routes=routes)
if __name__ == "__main__":
app.serve("0.0.0.0", 5000, debug=True)
'rfc3339': m.rfc3339()
}
def when(timestamp):
return {'timestamp': from_maya(maya.when(timestamp))}
def parse(timestamp):
return {'timestamp': from_maya(maya.parse(timestamp))}
def home():
return {
'now':
from_maya(maya.now()),
'urls':
['/', '/docs', '/when/:human-timestamp', '/parse/:machine-timestamp']
}
routes = [
Route('/when/{timestamp}', 'GET', when),
Route('/parse/{timestamp}', 'GET', parse),
Route('/', 'GET', home),
Include('/docs', docs_routes),
Include('/static', static_routes)
]
app = App(routes=routes)
from apistar import App, Route
from apistar.exceptions import APIException
from apistar.test import TestClient
def handled_exception():
raise APIException(detail='error', status_code=400)
def unhandled_exception():
raise Exception('Oh noes!')
app = App(routes=[
Route('/handled_exception/', 'GET', handled_exception),
Route('/unhandled_exception/', 'GET', unhandled_exception),
])
client = TestClient(app)
def test_handled_exception():
response = client.get('/handled_exception/')
assert response.status_code == 400
assert response.json() == {'message': 'error'}
def test_unhandled_exception():
with pytest.raises(Exception):
client.get('/unhandled_exception/')
from apistar import App, Route
def hello() -> dict:
return {"hello": "world"}
routes = [Route("/", "GET", hello)]
app = App(routes=routes)
app.serve('127.0.0.1', 5000, debug=True)
params = {"page": page, "page_size": page_size, "content": list(range(25))}
if count in ("0", 0, "False", "false", False):
params["count"] = False
return PageNumberResponse(**params)
routes = [
Route("/limit_offset",
"GET",
limit_offset,
"limit_offset",
documented=False),
Route("/page_number", "GET", page_number, "page_number", documented=False),
]
app = App(routes=routes, static_dir=None, docs_url=None, schema_url=None)
async_app = ASyncApp(routes=routes,
static_dir=None,
docs_url=None,
schema_url=None)
@pytest.fixture(params=[app, async_app])
def client(request):
return TestClient(request.param)
class TestLimitOffsetResponse:
def test_default_params(self, client):
response = client.get("/limit_offset")
assert response.status_code == 200
