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